strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSConsole:
  785    '''
  786    AWSConsole is currently unstable, and its API may change, or it may be removed,
  787    without a major version bump.
  788    '''
  789    __slots__ = [
  790        'bind_interface',
  791        'egress_filter',
  792        'enable_env_variables',
  793        'healthy',
  794        'id',
  795        'name',
  796        'port_override',
  797        'region',
  798        'remote_identity_group_id',
  799        'remote_identity_healthcheck_username',
  800        'role_arn',
  801        'role_external_id',
  802        'secret_store_id',
  803        'session_expiry',
  804        'subdomain',
  805        'tags',
  806    ]
  807
  808    def __init__(
  809        self,
  810        bind_interface=None,
  811        egress_filter=None,
  812        enable_env_variables=None,
  813        healthy=None,
  814        id=None,
  815        name=None,
  816        port_override=None,
  817        region=None,
  818        remote_identity_group_id=None,
  819        remote_identity_healthcheck_username=None,
  820        role_arn=None,
  821        role_external_id=None,
  822        secret_store_id=None,
  823        session_expiry=None,
  824        subdomain=None,
  825        tags=None,
  826    ):
  827        self.bind_interface = bind_interface if bind_interface is not None else ''
  828        '''
  829         Bind interface
  830        '''
  831        self.egress_filter = egress_filter if egress_filter is not None else ''
  832        '''
  833         A filter applied to the routing logic to pin datasource to nodes.
  834        '''
  835        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
  836        self.healthy = healthy if healthy is not None else False
  837        '''
  838         True if the datasource is reachable and the credentials are valid.
  839        '''
  840        self.id = id if id is not None else ''
  841        '''
  842         Unique identifier of the Resource.
  843        '''
  844        self.name = name if name is not None else ''
  845        '''
  846         Unique human-readable name of the Resource.
  847        '''
  848        self.port_override = port_override if port_override is not None else 0
  849        self.region = region if region is not None else ''
  850        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  851        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  852        self.role_arn = role_arn if role_arn is not None else ''
  853        self.role_external_id = role_external_id if role_external_id is not None else ''
  854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  855        '''
  856         ID of the secret store containing credentials for this resource, if any.
  857        '''
  858        self.session_expiry = session_expiry if session_expiry is not None else 0
  859        self.subdomain = subdomain if subdomain is not None else ''
  860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  861        '''
  862         Tags is a map of key, value pairs.
  863        '''
  864
  865    def __repr__(self):
  866        return '<sdm.AWSConsole ' + \
  867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  869            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
  870            'healthy: ' + repr(self.healthy) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'name: ' + repr(self.name) + ' ' +\
  873            'port_override: ' + repr(self.port_override) + ' ' +\
  874            'region: ' + repr(self.region) + ' ' +\
  875            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  876            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  877            'role_arn: ' + repr(self.role_arn) + ' ' +\
  878            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  880            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
  881            'subdomain: ' + repr(self.subdomain) + ' ' +\
  882            'tags: ' + repr(self.tags) + ' ' +\
  883            '>'
  884
  885    def to_dict(self):
  886        return {
  887            'bind_interface': self.bind_interface,
  888            'egress_filter': self.egress_filter,
  889            'enable_env_variables': self.enable_env_variables,
  890            'healthy': self.healthy,
  891            'id': self.id,
  892            'name': self.name,
  893            'port_override': self.port_override,
  894            'region': self.region,
  895            'remote_identity_group_id': self.remote_identity_group_id,
  896            'remote_identity_healthcheck_username':
  897            self.remote_identity_healthcheck_username,
  898            'role_arn': self.role_arn,
  899            'role_external_id': self.role_external_id,
  900            'secret_store_id': self.secret_store_id,
  901            'session_expiry': self.session_expiry,
  902            'subdomain': self.subdomain,
  903            'tags': self.tags,
  904        }
  905
  906    @classmethod
  907    def from_dict(cls, d):
  908        return cls(
  909            bind_interface=d.get('bind_interface'),
  910            egress_filter=d.get('egress_filter'),
  911            enable_env_variables=d.get('enable_env_variables'),
  912            healthy=d.get('healthy'),
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            port_override=d.get('port_override'),
  916            region=d.get('region'),
  917            remote_identity_group_id=d.get('remote_identity_group_id'),
  918            remote_identity_healthcheck_username=d.get(
  919                'remote_identity_healthcheck_username'),
  920            role_arn=d.get('role_arn'),
  921            role_external_id=d.get('role_external_id'),
  922            secret_store_id=d.get('secret_store_id'),
  923            session_expiry=d.get('session_expiry'),
  924            subdomain=d.get('subdomain'),
  925            tags=d.get('tags'),
  926        )
  927
  928
  929class AWSConsoleStaticKeyPair:
  930    '''
  931    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
  932    without a major version bump.
  933    '''
  934    __slots__ = [
  935        'access_key',
  936        'bind_interface',
  937        'egress_filter',
  938        'healthy',
  939        'id',
  940        'name',
  941        'port_override',
  942        'region',
  943        'remote_identity_group_id',
  944        'remote_identity_healthcheck_username',
  945        'role_arn',
  946        'role_external_id',
  947        'secret_access_key',
  948        'secret_store_id',
  949        'session_expiry',
  950        'subdomain',
  951        'tags',
  952    ]
  953
  954    def __init__(
  955        self,
  956        access_key=None,
  957        bind_interface=None,
  958        egress_filter=None,
  959        healthy=None,
  960        id=None,
  961        name=None,
  962        port_override=None,
  963        region=None,
  964        remote_identity_group_id=None,
  965        remote_identity_healthcheck_username=None,
  966        role_arn=None,
  967        role_external_id=None,
  968        secret_access_key=None,
  969        secret_store_id=None,
  970        session_expiry=None,
  971        subdomain=None,
  972        tags=None,
  973    ):
  974        self.access_key = access_key if access_key is not None else ''
  975        self.bind_interface = bind_interface if bind_interface is not None else ''
  976        '''
  977         Bind interface
  978        '''
  979        self.egress_filter = egress_filter if egress_filter is not None else ''
  980        '''
  981         A filter applied to the routing logic to pin datasource to nodes.
  982        '''
  983        self.healthy = healthy if healthy is not None else False
  984        '''
  985         True if the datasource is reachable and the credentials are valid.
  986        '''
  987        self.id = id if id is not None else ''
  988        '''
  989         Unique identifier of the Resource.
  990        '''
  991        self.name = name if name is not None else ''
  992        '''
  993         Unique human-readable name of the Resource.
  994        '''
  995        self.port_override = port_override if port_override is not None else 0
  996        self.region = region if region is not None else ''
  997        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  998        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  999        self.role_arn = role_arn if role_arn is not None else ''
 1000        self.role_external_id = role_external_id if role_external_id is not None else ''
 1001        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1003        '''
 1004         ID of the secret store containing credentials for this resource, if any.
 1005        '''
 1006        self.session_expiry = session_expiry if session_expiry is not None else 0
 1007        self.subdomain = subdomain if subdomain is not None else ''
 1008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1009        '''
 1010         Tags is a map of key, value pairs.
 1011        '''
 1012
 1013    def __repr__(self):
 1014        return '<sdm.AWSConsoleStaticKeyPair ' + \
 1015            'access_key: ' + repr(self.access_key) + ' ' +\
 1016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1018            'healthy: ' + repr(self.healthy) + ' ' +\
 1019            'id: ' + repr(self.id) + ' ' +\
 1020            'name: ' + repr(self.name) + ' ' +\
 1021            'port_override: ' + repr(self.port_override) + ' ' +\
 1022            'region: ' + repr(self.region) + ' ' +\
 1023            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1024            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1025            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1026            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1027            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1029            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
 1030            'subdomain: ' + repr(self.subdomain) + ' ' +\
 1031            'tags: ' + repr(self.tags) + ' ' +\
 1032            '>'
 1033
 1034    def to_dict(self):
 1035        return {
 1036            'access_key': self.access_key,
 1037            'bind_interface': self.bind_interface,
 1038            'egress_filter': self.egress_filter,
 1039            'healthy': self.healthy,
 1040            'id': self.id,
 1041            'name': self.name,
 1042            'port_override': self.port_override,
 1043            'region': self.region,
 1044            'remote_identity_group_id': self.remote_identity_group_id,
 1045            'remote_identity_healthcheck_username':
 1046            self.remote_identity_healthcheck_username,
 1047            'role_arn': self.role_arn,
 1048            'role_external_id': self.role_external_id,
 1049            'secret_access_key': self.secret_access_key,
 1050            'secret_store_id': self.secret_store_id,
 1051            'session_expiry': self.session_expiry,
 1052            'subdomain': self.subdomain,
 1053            'tags': self.tags,
 1054        }
 1055
 1056    @classmethod
 1057    def from_dict(cls, d):
 1058        return cls(
 1059            access_key=d.get('access_key'),
 1060            bind_interface=d.get('bind_interface'),
 1061            egress_filter=d.get('egress_filter'),
 1062            healthy=d.get('healthy'),
 1063            id=d.get('id'),
 1064            name=d.get('name'),
 1065            port_override=d.get('port_override'),
 1066            region=d.get('region'),
 1067            remote_identity_group_id=d.get('remote_identity_group_id'),
 1068            remote_identity_healthcheck_username=d.get(
 1069                'remote_identity_healthcheck_username'),
 1070            role_arn=d.get('role_arn'),
 1071            role_external_id=d.get('role_external_id'),
 1072            secret_access_key=d.get('secret_access_key'),
 1073            secret_store_id=d.get('secret_store_id'),
 1074            session_expiry=d.get('session_expiry'),
 1075            subdomain=d.get('subdomain'),
 1076            tags=d.get('tags'),
 1077        )
 1078
 1079
 1080class AWSStore:
 1081    __slots__ = [
 1082        'id',
 1083        'name',
 1084        'region',
 1085        'tags',
 1086    ]
 1087
 1088    def __init__(
 1089        self,
 1090        id=None,
 1091        name=None,
 1092        region=None,
 1093        tags=None,
 1094    ):
 1095        self.id = id if id is not None else ''
 1096        '''
 1097         Unique identifier of the SecretStore.
 1098        '''
 1099        self.name = name if name is not None else ''
 1100        '''
 1101         Unique human-readable name of the SecretStore.
 1102        '''
 1103        self.region = region if region is not None else ''
 1104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1105        '''
 1106         Tags is a map of key, value pairs.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AWSStore ' + \
 1111            'id: ' + repr(self.id) + ' ' +\
 1112            'name: ' + repr(self.name) + ' ' +\
 1113            'region: ' + repr(self.region) + ' ' +\
 1114            'tags: ' + repr(self.tags) + ' ' +\
 1115            '>'
 1116
 1117    def to_dict(self):
 1118        return {
 1119            'id': self.id,
 1120            'name': self.name,
 1121            'region': self.region,
 1122            'tags': self.tags,
 1123        }
 1124
 1125    @classmethod
 1126    def from_dict(cls, d):
 1127        return cls(
 1128            id=d.get('id'),
 1129            name=d.get('name'),
 1130            region=d.get('region'),
 1131            tags=d.get('tags'),
 1132        )
 1133
 1134
 1135class AccountAttachment:
 1136    '''
 1137         AccountAttachments assign an account to a role.
 1138    '''
 1139    __slots__ = [
 1140        'account_id',
 1141        'id',
 1142        'role_id',
 1143    ]
 1144
 1145    def __init__(
 1146        self,
 1147        account_id=None,
 1148        id=None,
 1149        role_id=None,
 1150    ):
 1151        self.account_id = account_id if account_id is not None else ''
 1152        '''
 1153         The id of the account of this AccountAttachment.
 1154        '''
 1155        self.id = id if id is not None else ''
 1156        '''
 1157         Unique identifier of the AccountAttachment.
 1158        '''
 1159        self.role_id = role_id if role_id is not None else ''
 1160        '''
 1161         The id of the attached role of this AccountAttachment.
 1162        '''
 1163
 1164    def __repr__(self):
 1165        return '<sdm.AccountAttachment ' + \
 1166            'account_id: ' + repr(self.account_id) + ' ' +\
 1167            'id: ' + repr(self.id) + ' ' +\
 1168            'role_id: ' + repr(self.role_id) + ' ' +\
 1169            '>'
 1170
 1171    def to_dict(self):
 1172        return {
 1173            'account_id': self.account_id,
 1174            'id': self.id,
 1175            'role_id': self.role_id,
 1176        }
 1177
 1178    @classmethod
 1179    def from_dict(cls, d):
 1180        return cls(
 1181            account_id=d.get('account_id'),
 1182            id=d.get('id'),
 1183            role_id=d.get('role_id'),
 1184        )
 1185
 1186
 1187class AccountAttachmentCreateResponse:
 1188    '''
 1189         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1190    '''
 1191    __slots__ = [
 1192        'account_attachment',
 1193        'meta',
 1194        'rate_limit',
 1195    ]
 1196
 1197    def __init__(
 1198        self,
 1199        account_attachment=None,
 1200        meta=None,
 1201        rate_limit=None,
 1202    ):
 1203        self.account_attachment = account_attachment if account_attachment is not None else None
 1204        '''
 1205         The created AccountAttachment.
 1206        '''
 1207        self.meta = meta if meta is not None else None
 1208        '''
 1209         Reserved for future use.
 1210        '''
 1211        self.rate_limit = rate_limit if rate_limit is not None else None
 1212        '''
 1213         Rate limit information.
 1214        '''
 1215
 1216    def __repr__(self):
 1217        return '<sdm.AccountAttachmentCreateResponse ' + \
 1218            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1219            'meta: ' + repr(self.meta) + ' ' +\
 1220            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1221            '>'
 1222
 1223    def to_dict(self):
 1224        return {
 1225            'account_attachment': self.account_attachment,
 1226            'meta': self.meta,
 1227            'rate_limit': self.rate_limit,
 1228        }
 1229
 1230    @classmethod
 1231    def from_dict(cls, d):
 1232        return cls(
 1233            account_attachment=d.get('account_attachment'),
 1234            meta=d.get('meta'),
 1235            rate_limit=d.get('rate_limit'),
 1236        )
 1237
 1238
 1239class AccountAttachmentDeleteResponse:
 1240    '''
 1241         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1242    '''
 1243    __slots__ = [
 1244        'meta',
 1245        'rate_limit',
 1246    ]
 1247
 1248    def __init__(
 1249        self,
 1250        meta=None,
 1251        rate_limit=None,
 1252    ):
 1253        self.meta = meta if meta is not None else None
 1254        '''
 1255         Reserved for future use.
 1256        '''
 1257        self.rate_limit = rate_limit if rate_limit is not None else None
 1258        '''
 1259         Rate limit information.
 1260        '''
 1261
 1262    def __repr__(self):
 1263        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1264            'meta: ' + repr(self.meta) + ' ' +\
 1265            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1266            '>'
 1267
 1268    def to_dict(self):
 1269        return {
 1270            'meta': self.meta,
 1271            'rate_limit': self.rate_limit,
 1272        }
 1273
 1274    @classmethod
 1275    def from_dict(cls, d):
 1276        return cls(
 1277            meta=d.get('meta'),
 1278            rate_limit=d.get('rate_limit'),
 1279        )
 1280
 1281
 1282class AccountAttachmentGetResponse:
 1283    '''
 1284         AccountAttachmentGetResponse returns a requested AccountAttachment.
 1285    '''
 1286    __slots__ = [
 1287        'account_attachment',
 1288        'meta',
 1289        'rate_limit',
 1290    ]
 1291
 1292    def __init__(
 1293        self,
 1294        account_attachment=None,
 1295        meta=None,
 1296        rate_limit=None,
 1297    ):
 1298        self.account_attachment = account_attachment if account_attachment is not None else None
 1299        '''
 1300         The requested AccountAttachment.
 1301        '''
 1302        self.meta = meta if meta is not None else None
 1303        '''
 1304         Reserved for future use.
 1305        '''
 1306        self.rate_limit = rate_limit if rate_limit is not None else None
 1307        '''
 1308         Rate limit information.
 1309        '''
 1310
 1311    def __repr__(self):
 1312        return '<sdm.AccountAttachmentGetResponse ' + \
 1313            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1314            'meta: ' + repr(self.meta) + ' ' +\
 1315            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1316            '>'
 1317
 1318    def to_dict(self):
 1319        return {
 1320            'account_attachment': self.account_attachment,
 1321            'meta': self.meta,
 1322            'rate_limit': self.rate_limit,
 1323        }
 1324
 1325    @classmethod
 1326    def from_dict(cls, d):
 1327        return cls(
 1328            account_attachment=d.get('account_attachment'),
 1329            meta=d.get('meta'),
 1330            rate_limit=d.get('rate_limit'),
 1331        )
 1332
 1333
 1334class AccountCreateResponse:
 1335    '''
 1336         AccountCreateResponse reports how the Accounts were created in the system.
 1337    '''
 1338    __slots__ = [
 1339        'account',
 1340        'meta',
 1341        'rate_limit',
 1342        'token',
 1343    ]
 1344
 1345    def __init__(
 1346        self,
 1347        account=None,
 1348        meta=None,
 1349        rate_limit=None,
 1350        token=None,
 1351    ):
 1352        self.account = account if account is not None else None
 1353        '''
 1354         The created Account.
 1355        '''
 1356        self.meta = meta if meta is not None else None
 1357        '''
 1358         Reserved for future use.
 1359        '''
 1360        self.rate_limit = rate_limit if rate_limit is not None else None
 1361        '''
 1362         Rate limit information.
 1363        '''
 1364        self.token = token if token is not None else ''
 1365        '''
 1366         The auth token generated for the Account. The Account will use this token to
 1367         authenticate with the strongDM API.
 1368        '''
 1369
 1370    def __repr__(self):
 1371        return '<sdm.AccountCreateResponse ' + \
 1372            'account: ' + repr(self.account) + ' ' +\
 1373            'meta: ' + repr(self.meta) + ' ' +\
 1374            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1375            'token: ' + repr(self.token) + ' ' +\
 1376            '>'
 1377
 1378    def to_dict(self):
 1379        return {
 1380            'account': self.account,
 1381            'meta': self.meta,
 1382            'rate_limit': self.rate_limit,
 1383            'token': self.token,
 1384        }
 1385
 1386    @classmethod
 1387    def from_dict(cls, d):
 1388        return cls(
 1389            account=d.get('account'),
 1390            meta=d.get('meta'),
 1391            rate_limit=d.get('rate_limit'),
 1392            token=d.get('token'),
 1393        )
 1394
 1395
 1396class AccountDeleteResponse:
 1397    '''
 1398         AccountDeleteResponse returns information about a Account that was deleted.
 1399    '''
 1400    __slots__ = [
 1401        'meta',
 1402        'rate_limit',
 1403    ]
 1404
 1405    def __init__(
 1406        self,
 1407        meta=None,
 1408        rate_limit=None,
 1409    ):
 1410        self.meta = meta if meta is not None else None
 1411        '''
 1412         Reserved for future use.
 1413        '''
 1414        self.rate_limit = rate_limit if rate_limit is not None else None
 1415        '''
 1416         Rate limit information.
 1417        '''
 1418
 1419    def __repr__(self):
 1420        return '<sdm.AccountDeleteResponse ' + \
 1421            'meta: ' + repr(self.meta) + ' ' +\
 1422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1423            '>'
 1424
 1425    def to_dict(self):
 1426        return {
 1427            'meta': self.meta,
 1428            'rate_limit': self.rate_limit,
 1429        }
 1430
 1431    @classmethod
 1432    def from_dict(cls, d):
 1433        return cls(
 1434            meta=d.get('meta'),
 1435            rate_limit=d.get('rate_limit'),
 1436        )
 1437
 1438
 1439class AccountGetResponse:
 1440    '''
 1441         AccountGetResponse returns a requested Account.
 1442    '''
 1443    __slots__ = [
 1444        'account',
 1445        'meta',
 1446        'rate_limit',
 1447    ]
 1448
 1449    def __init__(
 1450        self,
 1451        account=None,
 1452        meta=None,
 1453        rate_limit=None,
 1454    ):
 1455        self.account = account if account is not None else None
 1456        '''
 1457         The requested Account.
 1458        '''
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGetResponse ' + \
 1470            'account: ' + repr(self.account) + ' ' +\
 1471            'meta: ' + repr(self.meta) + ' ' +\
 1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1473            '>'
 1474
 1475    def to_dict(self):
 1476        return {
 1477            'account': self.account,
 1478            'meta': self.meta,
 1479            'rate_limit': self.rate_limit,
 1480        }
 1481
 1482    @classmethod
 1483    def from_dict(cls, d):
 1484        return cls(
 1485            account=d.get('account'),
 1486            meta=d.get('meta'),
 1487            rate_limit=d.get('rate_limit'),
 1488        )
 1489
 1490
 1491class AccountGrant:
 1492    '''
 1493         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1494    '''
 1495    __slots__ = [
 1496        'account_id',
 1497        'id',
 1498        'resource_id',
 1499        'start_from',
 1500        'valid_until',
 1501    ]
 1502
 1503    def __init__(
 1504        self,
 1505        account_id=None,
 1506        id=None,
 1507        resource_id=None,
 1508        start_from=None,
 1509        valid_until=None,
 1510    ):
 1511        self.account_id = account_id if account_id is not None else ''
 1512        '''
 1513         The account ID of this AccountGrant.
 1514        '''
 1515        self.id = id if id is not None else ''
 1516        '''
 1517         Unique identifier of the AccountGrant.
 1518        '''
 1519        self.resource_id = resource_id if resource_id is not None else ''
 1520        '''
 1521         The resource ID of this AccountGrant.
 1522        '''
 1523        self.start_from = start_from if start_from is not None else None
 1524        '''
 1525         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1526        '''
 1527        self.valid_until = valid_until if valid_until is not None else None
 1528        '''
 1529         The timestamp when the resource grant will expire.
 1530        '''
 1531
 1532    def __repr__(self):
 1533        return '<sdm.AccountGrant ' + \
 1534            'account_id: ' + repr(self.account_id) + ' ' +\
 1535            'id: ' + repr(self.id) + ' ' +\
 1536            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1537            'start_from: ' + repr(self.start_from) + ' ' +\
 1538            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1539            '>'
 1540
 1541    def to_dict(self):
 1542        return {
 1543            'account_id': self.account_id,
 1544            'id': self.id,
 1545            'resource_id': self.resource_id,
 1546            'start_from': self.start_from,
 1547            'valid_until': self.valid_until,
 1548        }
 1549
 1550    @classmethod
 1551    def from_dict(cls, d):
 1552        return cls(
 1553            account_id=d.get('account_id'),
 1554            id=d.get('id'),
 1555            resource_id=d.get('resource_id'),
 1556            start_from=d.get('start_from'),
 1557            valid_until=d.get('valid_until'),
 1558        )
 1559
 1560
 1561class AccountGrantCreateResponse:
 1562    '''
 1563         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1564    '''
 1565    __slots__ = [
 1566        'account_grant',
 1567        'meta',
 1568        'rate_limit',
 1569    ]
 1570
 1571    def __init__(
 1572        self,
 1573        account_grant=None,
 1574        meta=None,
 1575        rate_limit=None,
 1576    ):
 1577        self.account_grant = account_grant if account_grant is not None else None
 1578        '''
 1579         The created AccountGrant.
 1580        '''
 1581        self.meta = meta if meta is not None else None
 1582        '''
 1583         Reserved for future use.
 1584        '''
 1585        self.rate_limit = rate_limit if rate_limit is not None else None
 1586        '''
 1587         Rate limit information.
 1588        '''
 1589
 1590    def __repr__(self):
 1591        return '<sdm.AccountGrantCreateResponse ' + \
 1592            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1593            'meta: ' + repr(self.meta) + ' ' +\
 1594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1595            '>'
 1596
 1597    def to_dict(self):
 1598        return {
 1599            'account_grant': self.account_grant,
 1600            'meta': self.meta,
 1601            'rate_limit': self.rate_limit,
 1602        }
 1603
 1604    @classmethod
 1605    def from_dict(cls, d):
 1606        return cls(
 1607            account_grant=d.get('account_grant'),
 1608            meta=d.get('meta'),
 1609            rate_limit=d.get('rate_limit'),
 1610        )
 1611
 1612
 1613class AccountGrantDeleteResponse:
 1614    '''
 1615         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1616    '''
 1617    __slots__ = [
 1618        'meta',
 1619        'rate_limit',
 1620    ]
 1621
 1622    def __init__(
 1623        self,
 1624        meta=None,
 1625        rate_limit=None,
 1626    ):
 1627        self.meta = meta if meta is not None else None
 1628        '''
 1629         Reserved for future use.
 1630        '''
 1631        self.rate_limit = rate_limit if rate_limit is not None else None
 1632        '''
 1633         Rate limit information.
 1634        '''
 1635
 1636    def __repr__(self):
 1637        return '<sdm.AccountGrantDeleteResponse ' + \
 1638            'meta: ' + repr(self.meta) + ' ' +\
 1639            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1640            '>'
 1641
 1642    def to_dict(self):
 1643        return {
 1644            'meta': self.meta,
 1645            'rate_limit': self.rate_limit,
 1646        }
 1647
 1648    @classmethod
 1649    def from_dict(cls, d):
 1650        return cls(
 1651            meta=d.get('meta'),
 1652            rate_limit=d.get('rate_limit'),
 1653        )
 1654
 1655
 1656class AccountGrantGetResponse:
 1657    '''
 1658         AccountGrantGetResponse returns a requested AccountGrant.
 1659    '''
 1660    __slots__ = [
 1661        'account_grant',
 1662        'meta',
 1663        'rate_limit',
 1664    ]
 1665
 1666    def __init__(
 1667        self,
 1668        account_grant=None,
 1669        meta=None,
 1670        rate_limit=None,
 1671    ):
 1672        self.account_grant = account_grant if account_grant is not None else None
 1673        '''
 1674         The requested AccountGrant.
 1675        '''
 1676        self.meta = meta if meta is not None else None
 1677        '''
 1678         Reserved for future use.
 1679        '''
 1680        self.rate_limit = rate_limit if rate_limit is not None else None
 1681        '''
 1682         Rate limit information.
 1683        '''
 1684
 1685    def __repr__(self):
 1686        return '<sdm.AccountGrantGetResponse ' + \
 1687            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1688            'meta: ' + repr(self.meta) + ' ' +\
 1689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1690            '>'
 1691
 1692    def to_dict(self):
 1693        return {
 1694            'account_grant': self.account_grant,
 1695            'meta': self.meta,
 1696            'rate_limit': self.rate_limit,
 1697        }
 1698
 1699    @classmethod
 1700    def from_dict(cls, d):
 1701        return cls(
 1702            account_grant=d.get('account_grant'),
 1703            meta=d.get('meta'),
 1704            rate_limit=d.get('rate_limit'),
 1705        )
 1706
 1707
 1708class AccountUpdateResponse:
 1709    '''
 1710         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1711     a AccountUpdateRequest.
 1712    '''
 1713    __slots__ = [
 1714        'account',
 1715        'meta',
 1716        'rate_limit',
 1717    ]
 1718
 1719    def __init__(
 1720        self,
 1721        account=None,
 1722        meta=None,
 1723        rate_limit=None,
 1724    ):
 1725        self.account = account if account is not None else None
 1726        '''
 1727         The updated Account.
 1728        '''
 1729        self.meta = meta if meta is not None else None
 1730        '''
 1731         Reserved for future use.
 1732        '''
 1733        self.rate_limit = rate_limit if rate_limit is not None else None
 1734        '''
 1735         Rate limit information.
 1736        '''
 1737
 1738    def __repr__(self):
 1739        return '<sdm.AccountUpdateResponse ' + \
 1740            'account: ' + repr(self.account) + ' ' +\
 1741            'meta: ' + repr(self.meta) + ' ' +\
 1742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1743            '>'
 1744
 1745    def to_dict(self):
 1746        return {
 1747            'account': self.account,
 1748            'meta': self.meta,
 1749            'rate_limit': self.rate_limit,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            account=d.get('account'),
 1756            meta=d.get('meta'),
 1757            rate_limit=d.get('rate_limit'),
 1758        )
 1759
 1760
 1761class AmazonEKS:
 1762    __slots__ = [
 1763        'access_key',
 1764        'bind_interface',
 1765        'certificate_authority',
 1766        'cluster_name',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthcheck_namespace',
 1770        'healthy',
 1771        'id',
 1772        'name',
 1773        'region',
 1774        'remote_identity_group_id',
 1775        'remote_identity_healthcheck_username',
 1776        'role_arn',
 1777        'role_external_id',
 1778        'secret_access_key',
 1779        'secret_store_id',
 1780        'tags',
 1781    ]
 1782
 1783    def __init__(
 1784        self,
 1785        access_key=None,
 1786        bind_interface=None,
 1787        certificate_authority=None,
 1788        cluster_name=None,
 1789        egress_filter=None,
 1790        endpoint=None,
 1791        healthcheck_namespace=None,
 1792        healthy=None,
 1793        id=None,
 1794        name=None,
 1795        region=None,
 1796        remote_identity_group_id=None,
 1797        remote_identity_healthcheck_username=None,
 1798        role_arn=None,
 1799        role_external_id=None,
 1800        secret_access_key=None,
 1801        secret_store_id=None,
 1802        tags=None,
 1803    ):
 1804        self.access_key = access_key if access_key is not None else ''
 1805        self.bind_interface = bind_interface if bind_interface is not None else ''
 1806        '''
 1807         Bind interface
 1808        '''
 1809        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1810        self.cluster_name = cluster_name if cluster_name is not None else ''
 1811        self.egress_filter = egress_filter if egress_filter is not None else ''
 1812        '''
 1813         A filter applied to the routing logic to pin datasource to nodes.
 1814        '''
 1815        self.endpoint = endpoint if endpoint is not None else ''
 1816        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1817        '''
 1818         The path used to check the health of your connection.  Defaults to `default`.
 1819        '''
 1820        self.healthy = healthy if healthy is not None else False
 1821        '''
 1822         True if the datasource is reachable and the credentials are valid.
 1823        '''
 1824        self.id = id if id is not None else ''
 1825        '''
 1826         Unique identifier of the Resource.
 1827        '''
 1828        self.name = name if name is not None else ''
 1829        '''
 1830         Unique human-readable name of the Resource.
 1831        '''
 1832        self.region = region if region is not None else ''
 1833        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1834        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1835        self.role_arn = role_arn if role_arn is not None else ''
 1836        self.role_external_id = role_external_id if role_external_id is not None else ''
 1837        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1839        '''
 1840         ID of the secret store containing credentials for this resource, if any.
 1841        '''
 1842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1843        '''
 1844         Tags is a map of key, value pairs.
 1845        '''
 1846
 1847    def __repr__(self):
 1848        return '<sdm.AmazonEKS ' + \
 1849            'access_key: ' + repr(self.access_key) + ' ' +\
 1850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1851            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1852            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1854            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1855            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1856            'healthy: ' + repr(self.healthy) + ' ' +\
 1857            'id: ' + repr(self.id) + ' ' +\
 1858            'name: ' + repr(self.name) + ' ' +\
 1859            'region: ' + repr(self.region) + ' ' +\
 1860            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1861            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1862            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1863            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1864            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1866            'tags: ' + repr(self.tags) + ' ' +\
 1867            '>'
 1868
 1869    def to_dict(self):
 1870        return {
 1871            'access_key': self.access_key,
 1872            'bind_interface': self.bind_interface,
 1873            'certificate_authority': self.certificate_authority,
 1874            'cluster_name': self.cluster_name,
 1875            'egress_filter': self.egress_filter,
 1876            'endpoint': self.endpoint,
 1877            'healthcheck_namespace': self.healthcheck_namespace,
 1878            'healthy': self.healthy,
 1879            'id': self.id,
 1880            'name': self.name,
 1881            'region': self.region,
 1882            'remote_identity_group_id': self.remote_identity_group_id,
 1883            'remote_identity_healthcheck_username':
 1884            self.remote_identity_healthcheck_username,
 1885            'role_arn': self.role_arn,
 1886            'role_external_id': self.role_external_id,
 1887            'secret_access_key': self.secret_access_key,
 1888            'secret_store_id': self.secret_store_id,
 1889            'tags': self.tags,
 1890        }
 1891
 1892    @classmethod
 1893    def from_dict(cls, d):
 1894        return cls(
 1895            access_key=d.get('access_key'),
 1896            bind_interface=d.get('bind_interface'),
 1897            certificate_authority=d.get('certificate_authority'),
 1898            cluster_name=d.get('cluster_name'),
 1899            egress_filter=d.get('egress_filter'),
 1900            endpoint=d.get('endpoint'),
 1901            healthcheck_namespace=d.get('healthcheck_namespace'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            region=d.get('region'),
 1906            remote_identity_group_id=d.get('remote_identity_group_id'),
 1907            remote_identity_healthcheck_username=d.get(
 1908                'remote_identity_healthcheck_username'),
 1909            role_arn=d.get('role_arn'),
 1910            role_external_id=d.get('role_external_id'),
 1911            secret_access_key=d.get('secret_access_key'),
 1912            secret_store_id=d.get('secret_store_id'),
 1913            tags=d.get('tags'),
 1914        )
 1915
 1916
 1917class AmazonEKSUserImpersonation:
 1918    __slots__ = [
 1919        'access_key',
 1920        'bind_interface',
 1921        'certificate_authority',
 1922        'cluster_name',
 1923        'egress_filter',
 1924        'endpoint',
 1925        'healthcheck_namespace',
 1926        'healthy',
 1927        'id',
 1928        'name',
 1929        'region',
 1930        'role_arn',
 1931        'role_external_id',
 1932        'secret_access_key',
 1933        'secret_store_id',
 1934        'tags',
 1935    ]
 1936
 1937    def __init__(
 1938        self,
 1939        access_key=None,
 1940        bind_interface=None,
 1941        certificate_authority=None,
 1942        cluster_name=None,
 1943        egress_filter=None,
 1944        endpoint=None,
 1945        healthcheck_namespace=None,
 1946        healthy=None,
 1947        id=None,
 1948        name=None,
 1949        region=None,
 1950        role_arn=None,
 1951        role_external_id=None,
 1952        secret_access_key=None,
 1953        secret_store_id=None,
 1954        tags=None,
 1955    ):
 1956        self.access_key = access_key if access_key is not None else ''
 1957        self.bind_interface = bind_interface if bind_interface is not None else ''
 1958        '''
 1959         Bind interface
 1960        '''
 1961        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1962        self.cluster_name = cluster_name if cluster_name is not None else ''
 1963        self.egress_filter = egress_filter if egress_filter is not None else ''
 1964        '''
 1965         A filter applied to the routing logic to pin datasource to nodes.
 1966        '''
 1967        self.endpoint = endpoint if endpoint is not None else ''
 1968        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1969        '''
 1970         The path used to check the health of your connection.  Defaults to `default`.
 1971        '''
 1972        self.healthy = healthy if healthy is not None else False
 1973        '''
 1974         True if the datasource is reachable and the credentials are valid.
 1975        '''
 1976        self.id = id if id is not None else ''
 1977        '''
 1978         Unique identifier of the Resource.
 1979        '''
 1980        self.name = name if name is not None else ''
 1981        '''
 1982         Unique human-readable name of the Resource.
 1983        '''
 1984        self.region = region if region is not None else ''
 1985        self.role_arn = role_arn if role_arn is not None else ''
 1986        self.role_external_id = role_external_id if role_external_id is not None else ''
 1987        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1988        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1989        '''
 1990         ID of the secret store containing credentials for this resource, if any.
 1991        '''
 1992        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1993        '''
 1994         Tags is a map of key, value pairs.
 1995        '''
 1996
 1997    def __repr__(self):
 1998        return '<sdm.AmazonEKSUserImpersonation ' + \
 1999            'access_key: ' + repr(self.access_key) + ' ' +\
 2000            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2001            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2002            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2003            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2004            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2005            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2006            'healthy: ' + repr(self.healthy) + ' ' +\
 2007            'id: ' + repr(self.id) + ' ' +\
 2008            'name: ' + repr(self.name) + ' ' +\
 2009            'region: ' + repr(self.region) + ' ' +\
 2010            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2011            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2012            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2013            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2014            'tags: ' + repr(self.tags) + ' ' +\
 2015            '>'
 2016
 2017    def to_dict(self):
 2018        return {
 2019            'access_key': self.access_key,
 2020            'bind_interface': self.bind_interface,
 2021            'certificate_authority': self.certificate_authority,
 2022            'cluster_name': self.cluster_name,
 2023            'egress_filter': self.egress_filter,
 2024            'endpoint': self.endpoint,
 2025            'healthcheck_namespace': self.healthcheck_namespace,
 2026            'healthy': self.healthy,
 2027            'id': self.id,
 2028            'name': self.name,
 2029            'region': self.region,
 2030            'role_arn': self.role_arn,
 2031            'role_external_id': self.role_external_id,
 2032            'secret_access_key': self.secret_access_key,
 2033            'secret_store_id': self.secret_store_id,
 2034            'tags': self.tags,
 2035        }
 2036
 2037    @classmethod
 2038    def from_dict(cls, d):
 2039        return cls(
 2040            access_key=d.get('access_key'),
 2041            bind_interface=d.get('bind_interface'),
 2042            certificate_authority=d.get('certificate_authority'),
 2043            cluster_name=d.get('cluster_name'),
 2044            egress_filter=d.get('egress_filter'),
 2045            endpoint=d.get('endpoint'),
 2046            healthcheck_namespace=d.get('healthcheck_namespace'),
 2047            healthy=d.get('healthy'),
 2048            id=d.get('id'),
 2049            name=d.get('name'),
 2050            region=d.get('region'),
 2051            role_arn=d.get('role_arn'),
 2052            role_external_id=d.get('role_external_id'),
 2053            secret_access_key=d.get('secret_access_key'),
 2054            secret_store_id=d.get('secret_store_id'),
 2055            tags=d.get('tags'),
 2056        )
 2057
 2058
 2059class AmazonES:
 2060    __slots__ = [
 2061        'access_key',
 2062        'bind_interface',
 2063        'egress_filter',
 2064        'endpoint',
 2065        'healthy',
 2066        'id',
 2067        'name',
 2068        'port_override',
 2069        'region',
 2070        'role_arn',
 2071        'role_external_id',
 2072        'secret_access_key',
 2073        'secret_store_id',
 2074        'tags',
 2075    ]
 2076
 2077    def __init__(
 2078        self,
 2079        access_key=None,
 2080        bind_interface=None,
 2081        egress_filter=None,
 2082        endpoint=None,
 2083        healthy=None,
 2084        id=None,
 2085        name=None,
 2086        port_override=None,
 2087        region=None,
 2088        role_arn=None,
 2089        role_external_id=None,
 2090        secret_access_key=None,
 2091        secret_store_id=None,
 2092        tags=None,
 2093    ):
 2094        self.access_key = access_key if access_key is not None else ''
 2095        self.bind_interface = bind_interface if bind_interface is not None else ''
 2096        '''
 2097         Bind interface
 2098        '''
 2099        self.egress_filter = egress_filter if egress_filter is not None else ''
 2100        '''
 2101         A filter applied to the routing logic to pin datasource to nodes.
 2102        '''
 2103        self.endpoint = endpoint if endpoint is not None else ''
 2104        self.healthy = healthy if healthy is not None else False
 2105        '''
 2106         True if the datasource is reachable and the credentials are valid.
 2107        '''
 2108        self.id = id if id is not None else ''
 2109        '''
 2110         Unique identifier of the Resource.
 2111        '''
 2112        self.name = name if name is not None else ''
 2113        '''
 2114         Unique human-readable name of the Resource.
 2115        '''
 2116        self.port_override = port_override if port_override is not None else 0
 2117        self.region = region if region is not None else ''
 2118        self.role_arn = role_arn if role_arn is not None else ''
 2119        self.role_external_id = role_external_id if role_external_id is not None else ''
 2120        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2121        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2122        '''
 2123         ID of the secret store containing credentials for this resource, if any.
 2124        '''
 2125        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2126        '''
 2127         Tags is a map of key, value pairs.
 2128        '''
 2129
 2130    def __repr__(self):
 2131        return '<sdm.AmazonES ' + \
 2132            'access_key: ' + repr(self.access_key) + ' ' +\
 2133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2135            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2136            'healthy: ' + repr(self.healthy) + ' ' +\
 2137            'id: ' + repr(self.id) + ' ' +\
 2138            'name: ' + repr(self.name) + ' ' +\
 2139            'port_override: ' + repr(self.port_override) + ' ' +\
 2140            'region: ' + repr(self.region) + ' ' +\
 2141            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2142            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2143            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2145            'tags: ' + repr(self.tags) + ' ' +\
 2146            '>'
 2147
 2148    def to_dict(self):
 2149        return {
 2150            'access_key': self.access_key,
 2151            'bind_interface': self.bind_interface,
 2152            'egress_filter': self.egress_filter,
 2153            'endpoint': self.endpoint,
 2154            'healthy': self.healthy,
 2155            'id': self.id,
 2156            'name': self.name,
 2157            'port_override': self.port_override,
 2158            'region': self.region,
 2159            'role_arn': self.role_arn,
 2160            'role_external_id': self.role_external_id,
 2161            'secret_access_key': self.secret_access_key,
 2162            'secret_store_id': self.secret_store_id,
 2163            'tags': self.tags,
 2164        }
 2165
 2166    @classmethod
 2167    def from_dict(cls, d):
 2168        return cls(
 2169            access_key=d.get('access_key'),
 2170            bind_interface=d.get('bind_interface'),
 2171            egress_filter=d.get('egress_filter'),
 2172            endpoint=d.get('endpoint'),
 2173            healthy=d.get('healthy'),
 2174            id=d.get('id'),
 2175            name=d.get('name'),
 2176            port_override=d.get('port_override'),
 2177            region=d.get('region'),
 2178            role_arn=d.get('role_arn'),
 2179            role_external_id=d.get('role_external_id'),
 2180            secret_access_key=d.get('secret_access_key'),
 2181            secret_store_id=d.get('secret_store_id'),
 2182            tags=d.get('tags'),
 2183        )
 2184
 2185
 2186class AmazonMQAMQP091:
 2187    __slots__ = [
 2188        'bind_interface',
 2189        'egress_filter',
 2190        'healthy',
 2191        'hostname',
 2192        'id',
 2193        'name',
 2194        'password',
 2195        'port',
 2196        'port_override',
 2197        'secret_store_id',
 2198        'tags',
 2199        'tls_required',
 2200        'username',
 2201    ]
 2202
 2203    def __init__(
 2204        self,
 2205        bind_interface=None,
 2206        egress_filter=None,
 2207        healthy=None,
 2208        hostname=None,
 2209        id=None,
 2210        name=None,
 2211        password=None,
 2212        port=None,
 2213        port_override=None,
 2214        secret_store_id=None,
 2215        tags=None,
 2216        tls_required=None,
 2217        username=None,
 2218    ):
 2219        self.bind_interface = bind_interface if bind_interface is not None else ''
 2220        '''
 2221         Bind interface
 2222        '''
 2223        self.egress_filter = egress_filter if egress_filter is not None else ''
 2224        '''
 2225         A filter applied to the routing logic to pin datasource to nodes.
 2226        '''
 2227        self.healthy = healthy if healthy is not None else False
 2228        '''
 2229         True if the datasource is reachable and the credentials are valid.
 2230        '''
 2231        self.hostname = hostname if hostname is not None else ''
 2232        self.id = id if id is not None else ''
 2233        '''
 2234         Unique identifier of the Resource.
 2235        '''
 2236        self.name = name if name is not None else ''
 2237        '''
 2238         Unique human-readable name of the Resource.
 2239        '''
 2240        self.password = password if password is not None else ''
 2241        self.port = port if port is not None else 0
 2242        self.port_override = port_override if port_override is not None else 0
 2243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2244        '''
 2245         ID of the secret store containing credentials for this resource, if any.
 2246        '''
 2247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2248        '''
 2249         Tags is a map of key, value pairs.
 2250        '''
 2251        self.tls_required = tls_required if tls_required is not None else False
 2252        self.username = username if username is not None else ''
 2253
 2254    def __repr__(self):
 2255        return '<sdm.AmazonMQAMQP091 ' + \
 2256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2257            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2258            'healthy: ' + repr(self.healthy) + ' ' +\
 2259            'hostname: ' + repr(self.hostname) + ' ' +\
 2260            'id: ' + repr(self.id) + ' ' +\
 2261            'name: ' + repr(self.name) + ' ' +\
 2262            'password: ' + repr(self.password) + ' ' +\
 2263            'port: ' + repr(self.port) + ' ' +\
 2264            'port_override: ' + repr(self.port_override) + ' ' +\
 2265            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2266            'tags: ' + repr(self.tags) + ' ' +\
 2267            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2268            'username: ' + repr(self.username) + ' ' +\
 2269            '>'
 2270
 2271    def to_dict(self):
 2272        return {
 2273            'bind_interface': self.bind_interface,
 2274            'egress_filter': self.egress_filter,
 2275            'healthy': self.healthy,
 2276            'hostname': self.hostname,
 2277            'id': self.id,
 2278            'name': self.name,
 2279            'password': self.password,
 2280            'port': self.port,
 2281            'port_override': self.port_override,
 2282            'secret_store_id': self.secret_store_id,
 2283            'tags': self.tags,
 2284            'tls_required': self.tls_required,
 2285            'username': self.username,
 2286        }
 2287
 2288    @classmethod
 2289    def from_dict(cls, d):
 2290        return cls(
 2291            bind_interface=d.get('bind_interface'),
 2292            egress_filter=d.get('egress_filter'),
 2293            healthy=d.get('healthy'),
 2294            hostname=d.get('hostname'),
 2295            id=d.get('id'),
 2296            name=d.get('name'),
 2297            password=d.get('password'),
 2298            port=d.get('port'),
 2299            port_override=d.get('port_override'),
 2300            secret_store_id=d.get('secret_store_id'),
 2301            tags=d.get('tags'),
 2302            tls_required=d.get('tls_required'),
 2303            username=d.get('username'),
 2304        )
 2305
 2306
 2307class Athena:
 2308    __slots__ = [
 2309        'access_key',
 2310        'bind_interface',
 2311        'egress_filter',
 2312        'healthy',
 2313        'id',
 2314        'name',
 2315        'output',
 2316        'port_override',
 2317        'region',
 2318        'role_arn',
 2319        'role_external_id',
 2320        'secret_access_key',
 2321        'secret_store_id',
 2322        'tags',
 2323    ]
 2324
 2325    def __init__(
 2326        self,
 2327        access_key=None,
 2328        bind_interface=None,
 2329        egress_filter=None,
 2330        healthy=None,
 2331        id=None,
 2332        name=None,
 2333        output=None,
 2334        port_override=None,
 2335        region=None,
 2336        role_arn=None,
 2337        role_external_id=None,
 2338        secret_access_key=None,
 2339        secret_store_id=None,
 2340        tags=None,
 2341    ):
 2342        self.access_key = access_key if access_key is not None else ''
 2343        self.bind_interface = bind_interface if bind_interface is not None else ''
 2344        '''
 2345         Bind interface
 2346        '''
 2347        self.egress_filter = egress_filter if egress_filter is not None else ''
 2348        '''
 2349         A filter applied to the routing logic to pin datasource to nodes.
 2350        '''
 2351        self.healthy = healthy if healthy is not None else False
 2352        '''
 2353         True if the datasource is reachable and the credentials are valid.
 2354        '''
 2355        self.id = id if id is not None else ''
 2356        '''
 2357         Unique identifier of the Resource.
 2358        '''
 2359        self.name = name if name is not None else ''
 2360        '''
 2361         Unique human-readable name of the Resource.
 2362        '''
 2363        self.output = output if output is not None else ''
 2364        self.port_override = port_override if port_override is not None else 0
 2365        self.region = region if region is not None else ''
 2366        self.role_arn = role_arn if role_arn is not None else ''
 2367        self.role_external_id = role_external_id if role_external_id is not None else ''
 2368        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2370        '''
 2371         ID of the secret store containing credentials for this resource, if any.
 2372        '''
 2373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2374        '''
 2375         Tags is a map of key, value pairs.
 2376        '''
 2377
 2378    def __repr__(self):
 2379        return '<sdm.Athena ' + \
 2380            'access_key: ' + repr(self.access_key) + ' ' +\
 2381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2383            'healthy: ' + repr(self.healthy) + ' ' +\
 2384            'id: ' + repr(self.id) + ' ' +\
 2385            'name: ' + repr(self.name) + ' ' +\
 2386            'output: ' + repr(self.output) + ' ' +\
 2387            'port_override: ' + repr(self.port_override) + ' ' +\
 2388            'region: ' + repr(self.region) + ' ' +\
 2389            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2390            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2391            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2392            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2393            'tags: ' + repr(self.tags) + ' ' +\
 2394            '>'
 2395
 2396    def to_dict(self):
 2397        return {
 2398            'access_key': self.access_key,
 2399            'bind_interface': self.bind_interface,
 2400            'egress_filter': self.egress_filter,
 2401            'healthy': self.healthy,
 2402            'id': self.id,
 2403            'name': self.name,
 2404            'output': self.output,
 2405            'port_override': self.port_override,
 2406            'region': self.region,
 2407            'role_arn': self.role_arn,
 2408            'role_external_id': self.role_external_id,
 2409            'secret_access_key': self.secret_access_key,
 2410            'secret_store_id': self.secret_store_id,
 2411            'tags': self.tags,
 2412        }
 2413
 2414    @classmethod
 2415    def from_dict(cls, d):
 2416        return cls(
 2417            access_key=d.get('access_key'),
 2418            bind_interface=d.get('bind_interface'),
 2419            egress_filter=d.get('egress_filter'),
 2420            healthy=d.get('healthy'),
 2421            id=d.get('id'),
 2422            name=d.get('name'),
 2423            output=d.get('output'),
 2424            port_override=d.get('port_override'),
 2425            region=d.get('region'),
 2426            role_arn=d.get('role_arn'),
 2427            role_external_id=d.get('role_external_id'),
 2428            secret_access_key=d.get('secret_access_key'),
 2429            secret_store_id=d.get('secret_store_id'),
 2430            tags=d.get('tags'),
 2431        )
 2432
 2433
 2434class AuroraMysql:
 2435    __slots__ = [
 2436        'bind_interface',
 2437        'database',
 2438        'egress_filter',
 2439        'healthy',
 2440        'hostname',
 2441        'id',
 2442        'name',
 2443        'password',
 2444        'port',
 2445        'port_override',
 2446        'secret_store_id',
 2447        'tags',
 2448        'username',
 2449    ]
 2450
 2451    def __init__(
 2452        self,
 2453        bind_interface=None,
 2454        database=None,
 2455        egress_filter=None,
 2456        healthy=None,
 2457        hostname=None,
 2458        id=None,
 2459        name=None,
 2460        password=None,
 2461        port=None,
 2462        port_override=None,
 2463        secret_store_id=None,
 2464        tags=None,
 2465        username=None,
 2466    ):
 2467        self.bind_interface = bind_interface if bind_interface is not None else ''
 2468        '''
 2469         Bind interface
 2470        '''
 2471        self.database = database if database is not None else ''
 2472        self.egress_filter = egress_filter if egress_filter is not None else ''
 2473        '''
 2474         A filter applied to the routing logic to pin datasource to nodes.
 2475        '''
 2476        self.healthy = healthy if healthy is not None else False
 2477        '''
 2478         True if the datasource is reachable and the credentials are valid.
 2479        '''
 2480        self.hostname = hostname if hostname is not None else ''
 2481        self.id = id if id is not None else ''
 2482        '''
 2483         Unique identifier of the Resource.
 2484        '''
 2485        self.name = name if name is not None else ''
 2486        '''
 2487         Unique human-readable name of the Resource.
 2488        '''
 2489        self.password = password if password is not None else ''
 2490        self.port = port if port is not None else 0
 2491        self.port_override = port_override if port_override is not None else 0
 2492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2493        '''
 2494         ID of the secret store containing credentials for this resource, if any.
 2495        '''
 2496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2497        '''
 2498         Tags is a map of key, value pairs.
 2499        '''
 2500        self.username = username if username is not None else ''
 2501
 2502    def __repr__(self):
 2503        return '<sdm.AuroraMysql ' + \
 2504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2505            'database: ' + repr(self.database) + ' ' +\
 2506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2507            'healthy: ' + repr(self.healthy) + ' ' +\
 2508            'hostname: ' + repr(self.hostname) + ' ' +\
 2509            'id: ' + repr(self.id) + ' ' +\
 2510            'name: ' + repr(self.name) + ' ' +\
 2511            'password: ' + repr(self.password) + ' ' +\
 2512            'port: ' + repr(self.port) + ' ' +\
 2513            'port_override: ' + repr(self.port_override) + ' ' +\
 2514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2515            'tags: ' + repr(self.tags) + ' ' +\
 2516            'username: ' + repr(self.username) + ' ' +\
 2517            '>'
 2518
 2519    def to_dict(self):
 2520        return {
 2521            'bind_interface': self.bind_interface,
 2522            'database': self.database,
 2523            'egress_filter': self.egress_filter,
 2524            'healthy': self.healthy,
 2525            'hostname': self.hostname,
 2526            'id': self.id,
 2527            'name': self.name,
 2528            'password': self.password,
 2529            'port': self.port,
 2530            'port_override': self.port_override,
 2531            'secret_store_id': self.secret_store_id,
 2532            'tags': self.tags,
 2533            'username': self.username,
 2534        }
 2535
 2536    @classmethod
 2537    def from_dict(cls, d):
 2538        return cls(
 2539            bind_interface=d.get('bind_interface'),
 2540            database=d.get('database'),
 2541            egress_filter=d.get('egress_filter'),
 2542            healthy=d.get('healthy'),
 2543            hostname=d.get('hostname'),
 2544            id=d.get('id'),
 2545            name=d.get('name'),
 2546            password=d.get('password'),
 2547            port=d.get('port'),
 2548            port_override=d.get('port_override'),
 2549            secret_store_id=d.get('secret_store_id'),
 2550            tags=d.get('tags'),
 2551            username=d.get('username'),
 2552        )
 2553
 2554
 2555class AuroraPostgres:
 2556    __slots__ = [
 2557        'bind_interface',
 2558        'database',
 2559        'egress_filter',
 2560        'healthy',
 2561        'hostname',
 2562        'id',
 2563        'name',
 2564        'override_database',
 2565        'password',
 2566        'port',
 2567        'port_override',
 2568        'secret_store_id',
 2569        'tags',
 2570        'username',
 2571    ]
 2572
 2573    def __init__(
 2574        self,
 2575        bind_interface=None,
 2576        database=None,
 2577        egress_filter=None,
 2578        healthy=None,
 2579        hostname=None,
 2580        id=None,
 2581        name=None,
 2582        override_database=None,
 2583        password=None,
 2584        port=None,
 2585        port_override=None,
 2586        secret_store_id=None,
 2587        tags=None,
 2588        username=None,
 2589    ):
 2590        self.bind_interface = bind_interface if bind_interface is not None else ''
 2591        '''
 2592         Bind interface
 2593        '''
 2594        self.database = database if database is not None else ''
 2595        self.egress_filter = egress_filter if egress_filter is not None else ''
 2596        '''
 2597         A filter applied to the routing logic to pin datasource to nodes.
 2598        '''
 2599        self.healthy = healthy if healthy is not None else False
 2600        '''
 2601         True if the datasource is reachable and the credentials are valid.
 2602        '''
 2603        self.hostname = hostname if hostname is not None else ''
 2604        self.id = id if id is not None else ''
 2605        '''
 2606         Unique identifier of the Resource.
 2607        '''
 2608        self.name = name if name is not None else ''
 2609        '''
 2610         Unique human-readable name of the Resource.
 2611        '''
 2612        self.override_database = override_database if override_database is not None else False
 2613        self.password = password if password is not None else ''
 2614        self.port = port if port is not None else 0
 2615        self.port_override = port_override if port_override is not None else 0
 2616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2617        '''
 2618         ID of the secret store containing credentials for this resource, if any.
 2619        '''
 2620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2621        '''
 2622         Tags is a map of key, value pairs.
 2623        '''
 2624        self.username = username if username is not None else ''
 2625
 2626    def __repr__(self):
 2627        return '<sdm.AuroraPostgres ' + \
 2628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2629            'database: ' + repr(self.database) + ' ' +\
 2630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2631            'healthy: ' + repr(self.healthy) + ' ' +\
 2632            'hostname: ' + repr(self.hostname) + ' ' +\
 2633            'id: ' + repr(self.id) + ' ' +\
 2634            'name: ' + repr(self.name) + ' ' +\
 2635            'override_database: ' + repr(self.override_database) + ' ' +\
 2636            'password: ' + repr(self.password) + ' ' +\
 2637            'port: ' + repr(self.port) + ' ' +\
 2638            'port_override: ' + repr(self.port_override) + ' ' +\
 2639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2640            'tags: ' + repr(self.tags) + ' ' +\
 2641            'username: ' + repr(self.username) + ' ' +\
 2642            '>'
 2643
 2644    def to_dict(self):
 2645        return {
 2646            'bind_interface': self.bind_interface,
 2647            'database': self.database,
 2648            'egress_filter': self.egress_filter,
 2649            'healthy': self.healthy,
 2650            'hostname': self.hostname,
 2651            'id': self.id,
 2652            'name': self.name,
 2653            'override_database': self.override_database,
 2654            'password': self.password,
 2655            'port': self.port,
 2656            'port_override': self.port_override,
 2657            'secret_store_id': self.secret_store_id,
 2658            'tags': self.tags,
 2659            'username': self.username,
 2660        }
 2661
 2662    @classmethod
 2663    def from_dict(cls, d):
 2664        return cls(
 2665            bind_interface=d.get('bind_interface'),
 2666            database=d.get('database'),
 2667            egress_filter=d.get('egress_filter'),
 2668            healthy=d.get('healthy'),
 2669            hostname=d.get('hostname'),
 2670            id=d.get('id'),
 2671            name=d.get('name'),
 2672            override_database=d.get('override_database'),
 2673            password=d.get('password'),
 2674            port=d.get('port'),
 2675            port_override=d.get('port_override'),
 2676            secret_store_id=d.get('secret_store_id'),
 2677            tags=d.get('tags'),
 2678            username=d.get('username'),
 2679        )
 2680
 2681
 2682class Azure:
 2683    __slots__ = [
 2684        'app_id',
 2685        'bind_interface',
 2686        'egress_filter',
 2687        'healthy',
 2688        'id',
 2689        'name',
 2690        'password',
 2691        'secret_store_id',
 2692        'tags',
 2693        'tenant_id',
 2694    ]
 2695
 2696    def __init__(
 2697        self,
 2698        app_id=None,
 2699        bind_interface=None,
 2700        egress_filter=None,
 2701        healthy=None,
 2702        id=None,
 2703        name=None,
 2704        password=None,
 2705        secret_store_id=None,
 2706        tags=None,
 2707        tenant_id=None,
 2708    ):
 2709        self.app_id = app_id if app_id is not None else ''
 2710        self.bind_interface = bind_interface if bind_interface is not None else ''
 2711        '''
 2712         Bind interface
 2713        '''
 2714        self.egress_filter = egress_filter if egress_filter is not None else ''
 2715        '''
 2716         A filter applied to the routing logic to pin datasource to nodes.
 2717        '''
 2718        self.healthy = healthy if healthy is not None else False
 2719        '''
 2720         True if the datasource is reachable and the credentials are valid.
 2721        '''
 2722        self.id = id if id is not None else ''
 2723        '''
 2724         Unique identifier of the Resource.
 2725        '''
 2726        self.name = name if name is not None else ''
 2727        '''
 2728         Unique human-readable name of the Resource.
 2729        '''
 2730        self.password = password if password is not None else ''
 2731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2732        '''
 2733         ID of the secret store containing credentials for this resource, if any.
 2734        '''
 2735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2736        '''
 2737         Tags is a map of key, value pairs.
 2738        '''
 2739        self.tenant_id = tenant_id if tenant_id is not None else ''
 2740
 2741    def __repr__(self):
 2742        return '<sdm.Azure ' + \
 2743            'app_id: ' + repr(self.app_id) + ' ' +\
 2744            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2745            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2746            'healthy: ' + repr(self.healthy) + ' ' +\
 2747            'id: ' + repr(self.id) + ' ' +\
 2748            'name: ' + repr(self.name) + ' ' +\
 2749            'password: ' + repr(self.password) + ' ' +\
 2750            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2751            'tags: ' + repr(self.tags) + ' ' +\
 2752            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2753            '>'
 2754
 2755    def to_dict(self):
 2756        return {
 2757            'app_id': self.app_id,
 2758            'bind_interface': self.bind_interface,
 2759            'egress_filter': self.egress_filter,
 2760            'healthy': self.healthy,
 2761            'id': self.id,
 2762            'name': self.name,
 2763            'password': self.password,
 2764            'secret_store_id': self.secret_store_id,
 2765            'tags': self.tags,
 2766            'tenant_id': self.tenant_id,
 2767        }
 2768
 2769    @classmethod
 2770    def from_dict(cls, d):
 2771        return cls(
 2772            app_id=d.get('app_id'),
 2773            bind_interface=d.get('bind_interface'),
 2774            egress_filter=d.get('egress_filter'),
 2775            healthy=d.get('healthy'),
 2776            id=d.get('id'),
 2777            name=d.get('name'),
 2778            password=d.get('password'),
 2779            secret_store_id=d.get('secret_store_id'),
 2780            tags=d.get('tags'),
 2781            tenant_id=d.get('tenant_id'),
 2782        )
 2783
 2784
 2785class AzureCertificate:
 2786    __slots__ = [
 2787        'app_id',
 2788        'bind_interface',
 2789        'client_certificate',
 2790        'egress_filter',
 2791        'healthy',
 2792        'id',
 2793        'name',
 2794        'secret_store_id',
 2795        'tags',
 2796        'tenant_id',
 2797    ]
 2798
 2799    def __init__(
 2800        self,
 2801        app_id=None,
 2802        bind_interface=None,
 2803        client_certificate=None,
 2804        egress_filter=None,
 2805        healthy=None,
 2806        id=None,
 2807        name=None,
 2808        secret_store_id=None,
 2809        tags=None,
 2810        tenant_id=None,
 2811    ):
 2812        self.app_id = app_id if app_id is not None else ''
 2813        self.bind_interface = bind_interface if bind_interface is not None else ''
 2814        '''
 2815         Bind interface
 2816        '''
 2817        self.client_certificate = client_certificate if client_certificate is not None else ''
 2818        self.egress_filter = egress_filter if egress_filter is not None else ''
 2819        '''
 2820         A filter applied to the routing logic to pin datasource to nodes.
 2821        '''
 2822        self.healthy = healthy if healthy is not None else False
 2823        '''
 2824         True if the datasource is reachable and the credentials are valid.
 2825        '''
 2826        self.id = id if id is not None else ''
 2827        '''
 2828         Unique identifier of the Resource.
 2829        '''
 2830        self.name = name if name is not None else ''
 2831        '''
 2832         Unique human-readable name of the Resource.
 2833        '''
 2834        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2835        '''
 2836         ID of the secret store containing credentials for this resource, if any.
 2837        '''
 2838        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2839        '''
 2840         Tags is a map of key, value pairs.
 2841        '''
 2842        self.tenant_id = tenant_id if tenant_id is not None else ''
 2843
 2844    def __repr__(self):
 2845        return '<sdm.AzureCertificate ' + \
 2846            'app_id: ' + repr(self.app_id) + ' ' +\
 2847            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2848            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2849            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2850            'healthy: ' + repr(self.healthy) + ' ' +\
 2851            'id: ' + repr(self.id) + ' ' +\
 2852            'name: ' + repr(self.name) + ' ' +\
 2853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2854            'tags: ' + repr(self.tags) + ' ' +\
 2855            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2856            '>'
 2857
 2858    def to_dict(self):
 2859        return {
 2860            'app_id': self.app_id,
 2861            'bind_interface': self.bind_interface,
 2862            'client_certificate': self.client_certificate,
 2863            'egress_filter': self.egress_filter,
 2864            'healthy': self.healthy,
 2865            'id': self.id,
 2866            'name': self.name,
 2867            'secret_store_id': self.secret_store_id,
 2868            'tags': self.tags,
 2869            'tenant_id': self.tenant_id,
 2870        }
 2871
 2872    @classmethod
 2873    def from_dict(cls, d):
 2874        return cls(
 2875            app_id=d.get('app_id'),
 2876            bind_interface=d.get('bind_interface'),
 2877            client_certificate=d.get('client_certificate'),
 2878            egress_filter=d.get('egress_filter'),
 2879            healthy=d.get('healthy'),
 2880            id=d.get('id'),
 2881            name=d.get('name'),
 2882            secret_store_id=d.get('secret_store_id'),
 2883            tags=d.get('tags'),
 2884            tenant_id=d.get('tenant_id'),
 2885        )
 2886
 2887
 2888class AzureMysql:
 2889    '''
 2890    AzureMysql is currently unstable, and its API may change, or it may be removed,
 2891    without a major version bump.
 2892    '''
 2893    __slots__ = [
 2894        'bind_interface',
 2895        'database',
 2896        'egress_filter',
 2897        'healthy',
 2898        'hostname',
 2899        'id',
 2900        'name',
 2901        'password',
 2902        'port',
 2903        'port_override',
 2904        'secret_store_id',
 2905        'tags',
 2906        'username',
 2907    ]
 2908
 2909    def __init__(
 2910        self,
 2911        bind_interface=None,
 2912        database=None,
 2913        egress_filter=None,
 2914        healthy=None,
 2915        hostname=None,
 2916        id=None,
 2917        name=None,
 2918        password=None,
 2919        port=None,
 2920        port_override=None,
 2921        secret_store_id=None,
 2922        tags=None,
 2923        username=None,
 2924    ):
 2925        self.bind_interface = bind_interface if bind_interface is not None else ''
 2926        '''
 2927         Bind interface
 2928        '''
 2929        self.database = database if database is not None else ''
 2930        self.egress_filter = egress_filter if egress_filter is not None else ''
 2931        '''
 2932         A filter applied to the routing logic to pin datasource to nodes.
 2933        '''
 2934        self.healthy = healthy if healthy is not None else False
 2935        '''
 2936         True if the datasource is reachable and the credentials are valid.
 2937        '''
 2938        self.hostname = hostname if hostname is not None else ''
 2939        self.id = id if id is not None else ''
 2940        '''
 2941         Unique identifier of the Resource.
 2942        '''
 2943        self.name = name if name is not None else ''
 2944        '''
 2945         Unique human-readable name of the Resource.
 2946        '''
 2947        self.password = password if password is not None else ''
 2948        self.port = port if port is not None else 0
 2949        self.port_override = port_override if port_override is not None else 0
 2950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2951        '''
 2952         ID of the secret store containing credentials for this resource, if any.
 2953        '''
 2954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2955        '''
 2956         Tags is a map of key, value pairs.
 2957        '''
 2958        self.username = username if username is not None else ''
 2959
 2960    def __repr__(self):
 2961        return '<sdm.AzureMysql ' + \
 2962            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2963            'database: ' + repr(self.database) + ' ' +\
 2964            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2965            'healthy: ' + repr(self.healthy) + ' ' +\
 2966            'hostname: ' + repr(self.hostname) + ' ' +\
 2967            'id: ' + repr(self.id) + ' ' +\
 2968            'name: ' + repr(self.name) + ' ' +\
 2969            'password: ' + repr(self.password) + ' ' +\
 2970            'port: ' + repr(self.port) + ' ' +\
 2971            'port_override: ' + repr(self.port_override) + ' ' +\
 2972            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2973            'tags: ' + repr(self.tags) + ' ' +\
 2974            'username: ' + repr(self.username) + ' ' +\
 2975            '>'
 2976
 2977    def to_dict(self):
 2978        return {
 2979            'bind_interface': self.bind_interface,
 2980            'database': self.database,
 2981            'egress_filter': self.egress_filter,
 2982            'healthy': self.healthy,
 2983            'hostname': self.hostname,
 2984            'id': self.id,
 2985            'name': self.name,
 2986            'password': self.password,
 2987            'port': self.port,
 2988            'port_override': self.port_override,
 2989            'secret_store_id': self.secret_store_id,
 2990            'tags': self.tags,
 2991            'username': self.username,
 2992        }
 2993
 2994    @classmethod
 2995    def from_dict(cls, d):
 2996        return cls(
 2997            bind_interface=d.get('bind_interface'),
 2998            database=d.get('database'),
 2999            egress_filter=d.get('egress_filter'),
 3000            healthy=d.get('healthy'),
 3001            hostname=d.get('hostname'),
 3002            id=d.get('id'),
 3003            name=d.get('name'),
 3004            password=d.get('password'),
 3005            port=d.get('port'),
 3006            port_override=d.get('port_override'),
 3007            secret_store_id=d.get('secret_store_id'),
 3008            tags=d.get('tags'),
 3009            username=d.get('username'),
 3010        )
 3011
 3012
 3013class AzurePostgres:
 3014    __slots__ = [
 3015        'bind_interface',
 3016        'database',
 3017        'egress_filter',
 3018        'healthy',
 3019        'hostname',
 3020        'id',
 3021        'name',
 3022        'override_database',
 3023        'password',
 3024        'port',
 3025        'port_override',
 3026        'secret_store_id',
 3027        'tags',
 3028        'username',
 3029    ]
 3030
 3031    def __init__(
 3032        self,
 3033        bind_interface=None,
 3034        database=None,
 3035        egress_filter=None,
 3036        healthy=None,
 3037        hostname=None,
 3038        id=None,
 3039        name=None,
 3040        override_database=None,
 3041        password=None,
 3042        port=None,
 3043        port_override=None,
 3044        secret_store_id=None,
 3045        tags=None,
 3046        username=None,
 3047    ):
 3048        self.bind_interface = bind_interface if bind_interface is not None else ''
 3049        '''
 3050         Bind interface
 3051        '''
 3052        self.database = database if database is not None else ''
 3053        self.egress_filter = egress_filter if egress_filter is not None else ''
 3054        '''
 3055         A filter applied to the routing logic to pin datasource to nodes.
 3056        '''
 3057        self.healthy = healthy if healthy is not None else False
 3058        '''
 3059         True if the datasource is reachable and the credentials are valid.
 3060        '''
 3061        self.hostname = hostname if hostname is not None else ''
 3062        self.id = id if id is not None else ''
 3063        '''
 3064         Unique identifier of the Resource.
 3065        '''
 3066        self.name = name if name is not None else ''
 3067        '''
 3068         Unique human-readable name of the Resource.
 3069        '''
 3070        self.override_database = override_database if override_database is not None else False
 3071        self.password = password if password is not None else ''
 3072        self.port = port if port is not None else 0
 3073        self.port_override = port_override if port_override is not None else 0
 3074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3075        '''
 3076         ID of the secret store containing credentials for this resource, if any.
 3077        '''
 3078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3079        '''
 3080         Tags is a map of key, value pairs.
 3081        '''
 3082        self.username = username if username is not None else ''
 3083
 3084    def __repr__(self):
 3085        return '<sdm.AzurePostgres ' + \
 3086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3087            'database: ' + repr(self.database) + ' ' +\
 3088            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3089            'healthy: ' + repr(self.healthy) + ' ' +\
 3090            'hostname: ' + repr(self.hostname) + ' ' +\
 3091            'id: ' + repr(self.id) + ' ' +\
 3092            'name: ' + repr(self.name) + ' ' +\
 3093            'override_database: ' + repr(self.override_database) + ' ' +\
 3094            'password: ' + repr(self.password) + ' ' +\
 3095            'port: ' + repr(self.port) + ' ' +\
 3096            'port_override: ' + repr(self.port_override) + ' ' +\
 3097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3098            'tags: ' + repr(self.tags) + ' ' +\
 3099            'username: ' + repr(self.username) + ' ' +\
 3100            '>'
 3101
 3102    def to_dict(self):
 3103        return {
 3104            'bind_interface': self.bind_interface,
 3105            'database': self.database,
 3106            'egress_filter': self.egress_filter,
 3107            'healthy': self.healthy,
 3108            'hostname': self.hostname,
 3109            'id': self.id,
 3110            'name': self.name,
 3111            'override_database': self.override_database,
 3112            'password': self.password,
 3113            'port': self.port,
 3114            'port_override': self.port_override,
 3115            'secret_store_id': self.secret_store_id,
 3116            'tags': self.tags,
 3117            'username': self.username,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            bind_interface=d.get('bind_interface'),
 3124            database=d.get('database'),
 3125            egress_filter=d.get('egress_filter'),
 3126            healthy=d.get('healthy'),
 3127            hostname=d.get('hostname'),
 3128            id=d.get('id'),
 3129            name=d.get('name'),
 3130            override_database=d.get('override_database'),
 3131            password=d.get('password'),
 3132            port=d.get('port'),
 3133            port_override=d.get('port_override'),
 3134            secret_store_id=d.get('secret_store_id'),
 3135            tags=d.get('tags'),
 3136            username=d.get('username'),
 3137        )
 3138
 3139
 3140class AzureStore:
 3141    __slots__ = [
 3142        'id',
 3143        'name',
 3144        'tags',
 3145        'vault_uri',
 3146    ]
 3147
 3148    def __init__(
 3149        self,
 3150        id=None,
 3151        name=None,
 3152        tags=None,
 3153        vault_uri=None,
 3154    ):
 3155        self.id = id if id is not None else ''
 3156        '''
 3157         Unique identifier of the SecretStore.
 3158        '''
 3159        self.name = name if name is not None else ''
 3160        '''
 3161         Unique human-readable name of the SecretStore.
 3162        '''
 3163        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3164        '''
 3165         Tags is a map of key, value pairs.
 3166        '''
 3167        self.vault_uri = vault_uri if vault_uri is not None else ''
 3168
 3169    def __repr__(self):
 3170        return '<sdm.AzureStore ' + \
 3171            'id: ' + repr(self.id) + ' ' +\
 3172            'name: ' + repr(self.name) + ' ' +\
 3173            'tags: ' + repr(self.tags) + ' ' +\
 3174            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3175            '>'
 3176
 3177    def to_dict(self):
 3178        return {
 3179            'id': self.id,
 3180            'name': self.name,
 3181            'tags': self.tags,
 3182            'vault_uri': self.vault_uri,
 3183        }
 3184
 3185    @classmethod
 3186    def from_dict(cls, d):
 3187        return cls(
 3188            id=d.get('id'),
 3189            name=d.get('name'),
 3190            tags=d.get('tags'),
 3191            vault_uri=d.get('vault_uri'),
 3192        )
 3193
 3194
 3195class BigQuery:
 3196    __slots__ = [
 3197        'bind_interface',
 3198        'egress_filter',
 3199        'endpoint',
 3200        'healthy',
 3201        'id',
 3202        'name',
 3203        'port_override',
 3204        'private_key',
 3205        'project',
 3206        'secret_store_id',
 3207        'tags',
 3208        'username',
 3209    ]
 3210
 3211    def __init__(
 3212        self,
 3213        bind_interface=None,
 3214        egress_filter=None,
 3215        endpoint=None,
 3216        healthy=None,
 3217        id=None,
 3218        name=None,
 3219        port_override=None,
 3220        private_key=None,
 3221        project=None,
 3222        secret_store_id=None,
 3223        tags=None,
 3224        username=None,
 3225    ):
 3226        self.bind_interface = bind_interface if bind_interface is not None else ''
 3227        '''
 3228         Bind interface
 3229        '''
 3230        self.egress_filter = egress_filter if egress_filter is not None else ''
 3231        '''
 3232         A filter applied to the routing logic to pin datasource to nodes.
 3233        '''
 3234        self.endpoint = endpoint if endpoint is not None else ''
 3235        self.healthy = healthy if healthy is not None else False
 3236        '''
 3237         True if the datasource is reachable and the credentials are valid.
 3238        '''
 3239        self.id = id if id is not None else ''
 3240        '''
 3241         Unique identifier of the Resource.
 3242        '''
 3243        self.name = name if name is not None else ''
 3244        '''
 3245         Unique human-readable name of the Resource.
 3246        '''
 3247        self.port_override = port_override if port_override is not None else 0
 3248        self.private_key = private_key if private_key is not None else ''
 3249        self.project = project if project is not None else ''
 3250        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3251        '''
 3252         ID of the secret store containing credentials for this resource, if any.
 3253        '''
 3254        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3255        '''
 3256         Tags is a map of key, value pairs.
 3257        '''
 3258        self.username = username if username is not None else ''
 3259
 3260    def __repr__(self):
 3261        return '<sdm.BigQuery ' + \
 3262            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3263            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3264            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3265            'healthy: ' + repr(self.healthy) + ' ' +\
 3266            'id: ' + repr(self.id) + ' ' +\
 3267            'name: ' + repr(self.name) + ' ' +\
 3268            'port_override: ' + repr(self.port_override) + ' ' +\
 3269            'private_key: ' + repr(self.private_key) + ' ' +\
 3270            'project: ' + repr(self.project) + ' ' +\
 3271            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3272            'tags: ' + repr(self.tags) + ' ' +\
 3273            'username: ' + repr(self.username) + ' ' +\
 3274            '>'
 3275
 3276    def to_dict(self):
 3277        return {
 3278            'bind_interface': self.bind_interface,
 3279            'egress_filter': self.egress_filter,
 3280            'endpoint': self.endpoint,
 3281            'healthy': self.healthy,
 3282            'id': self.id,
 3283            'name': self.name,
 3284            'port_override': self.port_override,
 3285            'private_key': self.private_key,
 3286            'project': self.project,
 3287            'secret_store_id': self.secret_store_id,
 3288            'tags': self.tags,
 3289            'username': self.username,
 3290        }
 3291
 3292    @classmethod
 3293    def from_dict(cls, d):
 3294        return cls(
 3295            bind_interface=d.get('bind_interface'),
 3296            egress_filter=d.get('egress_filter'),
 3297            endpoint=d.get('endpoint'),
 3298            healthy=d.get('healthy'),
 3299            id=d.get('id'),
 3300            name=d.get('name'),
 3301            port_override=d.get('port_override'),
 3302            private_key=d.get('private_key'),
 3303            project=d.get('project'),
 3304            secret_store_id=d.get('secret_store_id'),
 3305            tags=d.get('tags'),
 3306            username=d.get('username'),
 3307        )
 3308
 3309
 3310class Cassandra:
 3311    __slots__ = [
 3312        'bind_interface',
 3313        'egress_filter',
 3314        'healthy',
 3315        'hostname',
 3316        'id',
 3317        'name',
 3318        'password',
 3319        'port',
 3320        'port_override',
 3321        'secret_store_id',
 3322        'tags',
 3323        'tls_required',
 3324        'username',
 3325    ]
 3326
 3327    def __init__(
 3328        self,
 3329        bind_interface=None,
 3330        egress_filter=None,
 3331        healthy=None,
 3332        hostname=None,
 3333        id=None,
 3334        name=None,
 3335        password=None,
 3336        port=None,
 3337        port_override=None,
 3338        secret_store_id=None,
 3339        tags=None,
 3340        tls_required=None,
 3341        username=None,
 3342    ):
 3343        self.bind_interface = bind_interface if bind_interface is not None else ''
 3344        '''
 3345         Bind interface
 3346        '''
 3347        self.egress_filter = egress_filter if egress_filter is not None else ''
 3348        '''
 3349         A filter applied to the routing logic to pin datasource to nodes.
 3350        '''
 3351        self.healthy = healthy if healthy is not None else False
 3352        '''
 3353         True if the datasource is reachable and the credentials are valid.
 3354        '''
 3355        self.hostname = hostname if hostname is not None else ''
 3356        self.id = id if id is not None else ''
 3357        '''
 3358         Unique identifier of the Resource.
 3359        '''
 3360        self.name = name if name is not None else ''
 3361        '''
 3362         Unique human-readable name of the Resource.
 3363        '''
 3364        self.password = password if password is not None else ''
 3365        self.port = port if port is not None else 0
 3366        self.port_override = port_override if port_override is not None else 0
 3367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3368        '''
 3369         ID of the secret store containing credentials for this resource, if any.
 3370        '''
 3371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3372        '''
 3373         Tags is a map of key, value pairs.
 3374        '''
 3375        self.tls_required = tls_required if tls_required is not None else False
 3376        self.username = username if username is not None else ''
 3377
 3378    def __repr__(self):
 3379        return '<sdm.Cassandra ' + \
 3380            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3381            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3382            'healthy: ' + repr(self.healthy) + ' ' +\
 3383            'hostname: ' + repr(self.hostname) + ' ' +\
 3384            'id: ' + repr(self.id) + ' ' +\
 3385            'name: ' + repr(self.name) + ' ' +\
 3386            'password: ' + repr(self.password) + ' ' +\
 3387            'port: ' + repr(self.port) + ' ' +\
 3388            'port_override: ' + repr(self.port_override) + ' ' +\
 3389            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3390            'tags: ' + repr(self.tags) + ' ' +\
 3391            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3392            'username: ' + repr(self.username) + ' ' +\
 3393            '>'
 3394
 3395    def to_dict(self):
 3396        return {
 3397            'bind_interface': self.bind_interface,
 3398            'egress_filter': self.egress_filter,
 3399            'healthy': self.healthy,
 3400            'hostname': self.hostname,
 3401            'id': self.id,
 3402            'name': self.name,
 3403            'password': self.password,
 3404            'port': self.port,
 3405            'port_override': self.port_override,
 3406            'secret_store_id': self.secret_store_id,
 3407            'tags': self.tags,
 3408            'tls_required': self.tls_required,
 3409            'username': self.username,
 3410        }
 3411
 3412    @classmethod
 3413    def from_dict(cls, d):
 3414        return cls(
 3415            bind_interface=d.get('bind_interface'),
 3416            egress_filter=d.get('egress_filter'),
 3417            healthy=d.get('healthy'),
 3418            hostname=d.get('hostname'),
 3419            id=d.get('id'),
 3420            name=d.get('name'),
 3421            password=d.get('password'),
 3422            port=d.get('port'),
 3423            port_override=d.get('port_override'),
 3424            secret_store_id=d.get('secret_store_id'),
 3425            tags=d.get('tags'),
 3426            tls_required=d.get('tls_required'),
 3427            username=d.get('username'),
 3428        )
 3429
 3430
 3431class Citus:
 3432    __slots__ = [
 3433        'bind_interface',
 3434        'database',
 3435        'egress_filter',
 3436        'healthy',
 3437        'hostname',
 3438        'id',
 3439        'name',
 3440        'override_database',
 3441        'password',
 3442        'port',
 3443        'port_override',
 3444        'secret_store_id',
 3445        'tags',
 3446        'username',
 3447    ]
 3448
 3449    def __init__(
 3450        self,
 3451        bind_interface=None,
 3452        database=None,
 3453        egress_filter=None,
 3454        healthy=None,
 3455        hostname=None,
 3456        id=None,
 3457        name=None,
 3458        override_database=None,
 3459        password=None,
 3460        port=None,
 3461        port_override=None,
 3462        secret_store_id=None,
 3463        tags=None,
 3464        username=None,
 3465    ):
 3466        self.bind_interface = bind_interface if bind_interface is not None else ''
 3467        '''
 3468         Bind interface
 3469        '''
 3470        self.database = database if database is not None else ''
 3471        self.egress_filter = egress_filter if egress_filter is not None else ''
 3472        '''
 3473         A filter applied to the routing logic to pin datasource to nodes.
 3474        '''
 3475        self.healthy = healthy if healthy is not None else False
 3476        '''
 3477         True if the datasource is reachable and the credentials are valid.
 3478        '''
 3479        self.hostname = hostname if hostname is not None else ''
 3480        self.id = id if id is not None else ''
 3481        '''
 3482         Unique identifier of the Resource.
 3483        '''
 3484        self.name = name if name is not None else ''
 3485        '''
 3486         Unique human-readable name of the Resource.
 3487        '''
 3488        self.override_database = override_database if override_database is not None else False
 3489        self.password = password if password is not None else ''
 3490        self.port = port if port is not None else 0
 3491        self.port_override = port_override if port_override is not None else 0
 3492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3493        '''
 3494         ID of the secret store containing credentials for this resource, if any.
 3495        '''
 3496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3497        '''
 3498         Tags is a map of key, value pairs.
 3499        '''
 3500        self.username = username if username is not None else ''
 3501
 3502    def __repr__(self):
 3503        return '<sdm.Citus ' + \
 3504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3505            'database: ' + repr(self.database) + ' ' +\
 3506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3507            'healthy: ' + repr(self.healthy) + ' ' +\
 3508            'hostname: ' + repr(self.hostname) + ' ' +\
 3509            'id: ' + repr(self.id) + ' ' +\
 3510            'name: ' + repr(self.name) + ' ' +\
 3511            'override_database: ' + repr(self.override_database) + ' ' +\
 3512            'password: ' + repr(self.password) + ' ' +\
 3513            'port: ' + repr(self.port) + ' ' +\
 3514            'port_override: ' + repr(self.port_override) + ' ' +\
 3515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3516            'tags: ' + repr(self.tags) + ' ' +\
 3517            'username: ' + repr(self.username) + ' ' +\
 3518            '>'
 3519
 3520    def to_dict(self):
 3521        return {
 3522            'bind_interface': self.bind_interface,
 3523            'database': self.database,
 3524            'egress_filter': self.egress_filter,
 3525            'healthy': self.healthy,
 3526            'hostname': self.hostname,
 3527            'id': self.id,
 3528            'name': self.name,
 3529            'override_database': self.override_database,
 3530            'password': self.password,
 3531            'port': self.port,
 3532            'port_override': self.port_override,
 3533            'secret_store_id': self.secret_store_id,
 3534            'tags': self.tags,
 3535            'username': self.username,
 3536        }
 3537
 3538    @classmethod
 3539    def from_dict(cls, d):
 3540        return cls(
 3541            bind_interface=d.get('bind_interface'),
 3542            database=d.get('database'),
 3543            egress_filter=d.get('egress_filter'),
 3544            healthy=d.get('healthy'),
 3545            hostname=d.get('hostname'),
 3546            id=d.get('id'),
 3547            name=d.get('name'),
 3548            override_database=d.get('override_database'),
 3549            password=d.get('password'),
 3550            port=d.get('port'),
 3551            port_override=d.get('port_override'),
 3552            secret_store_id=d.get('secret_store_id'),
 3553            tags=d.get('tags'),
 3554            username=d.get('username'),
 3555        )
 3556
 3557
 3558class Clustrix:
 3559    __slots__ = [
 3560        'bind_interface',
 3561        'database',
 3562        'egress_filter',
 3563        'healthy',
 3564        'hostname',
 3565        'id',
 3566        'name',
 3567        'password',
 3568        'port',
 3569        'port_override',
 3570        'secret_store_id',
 3571        'tags',
 3572        'username',
 3573    ]
 3574
 3575    def __init__(
 3576        self,
 3577        bind_interface=None,
 3578        database=None,
 3579        egress_filter=None,
 3580        healthy=None,
 3581        hostname=None,
 3582        id=None,
 3583        name=None,
 3584        password=None,
 3585        port=None,
 3586        port_override=None,
 3587        secret_store_id=None,
 3588        tags=None,
 3589        username=None,
 3590    ):
 3591        self.bind_interface = bind_interface if bind_interface is not None else ''
 3592        '''
 3593         Bind interface
 3594        '''
 3595        self.database = database if database is not None else ''
 3596        self.egress_filter = egress_filter if egress_filter is not None else ''
 3597        '''
 3598         A filter applied to the routing logic to pin datasource to nodes.
 3599        '''
 3600        self.healthy = healthy if healthy is not None else False
 3601        '''
 3602         True if the datasource is reachable and the credentials are valid.
 3603        '''
 3604        self.hostname = hostname if hostname is not None else ''
 3605        self.id = id if id is not None else ''
 3606        '''
 3607         Unique identifier of the Resource.
 3608        '''
 3609        self.name = name if name is not None else ''
 3610        '''
 3611         Unique human-readable name of the Resource.
 3612        '''
 3613        self.password = password if password is not None else ''
 3614        self.port = port if port is not None else 0
 3615        self.port_override = port_override if port_override is not None else 0
 3616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3617        '''
 3618         ID of the secret store containing credentials for this resource, if any.
 3619        '''
 3620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3621        '''
 3622         Tags is a map of key, value pairs.
 3623        '''
 3624        self.username = username if username is not None else ''
 3625
 3626    def __repr__(self):
 3627        return '<sdm.Clustrix ' + \
 3628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3629            'database: ' + repr(self.database) + ' ' +\
 3630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3631            'healthy: ' + repr(self.healthy) + ' ' +\
 3632            'hostname: ' + repr(self.hostname) + ' ' +\
 3633            'id: ' + repr(self.id) + ' ' +\
 3634            'name: ' + repr(self.name) + ' ' +\
 3635            'password: ' + repr(self.password) + ' ' +\
 3636            'port: ' + repr(self.port) + ' ' +\
 3637            'port_override: ' + repr(self.port_override) + ' ' +\
 3638            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3639            'tags: ' + repr(self.tags) + ' ' +\
 3640            'username: ' + repr(self.username) + ' ' +\
 3641            '>'
 3642
 3643    def to_dict(self):
 3644        return {
 3645            'bind_interface': self.bind_interface,
 3646            'database': self.database,
 3647            'egress_filter': self.egress_filter,
 3648            'healthy': self.healthy,
 3649            'hostname': self.hostname,
 3650            'id': self.id,
 3651            'name': self.name,
 3652            'password': self.password,
 3653            'port': self.port,
 3654            'port_override': self.port_override,
 3655            'secret_store_id': self.secret_store_id,
 3656            'tags': self.tags,
 3657            'username': self.username,
 3658        }
 3659
 3660    @classmethod
 3661    def from_dict(cls, d):
 3662        return cls(
 3663            bind_interface=d.get('bind_interface'),
 3664            database=d.get('database'),
 3665            egress_filter=d.get('egress_filter'),
 3666            healthy=d.get('healthy'),
 3667            hostname=d.get('hostname'),
 3668            id=d.get('id'),
 3669            name=d.get('name'),
 3670            password=d.get('password'),
 3671            port=d.get('port'),
 3672            port_override=d.get('port_override'),
 3673            secret_store_id=d.get('secret_store_id'),
 3674            tags=d.get('tags'),
 3675            username=d.get('username'),
 3676        )
 3677
 3678
 3679class Cockroach:
 3680    __slots__ = [
 3681        'bind_interface',
 3682        'database',
 3683        'egress_filter',
 3684        'healthy',
 3685        'hostname',
 3686        'id',
 3687        'name',
 3688        'override_database',
 3689        'password',
 3690        'port',
 3691        'port_override',
 3692        'secret_store_id',
 3693        'tags',
 3694        'username',
 3695    ]
 3696
 3697    def __init__(
 3698        self,
 3699        bind_interface=None,
 3700        database=None,
 3701        egress_filter=None,
 3702        healthy=None,
 3703        hostname=None,
 3704        id=None,
 3705        name=None,
 3706        override_database=None,
 3707        password=None,
 3708        port=None,
 3709        port_override=None,
 3710        secret_store_id=None,
 3711        tags=None,
 3712        username=None,
 3713    ):
 3714        self.bind_interface = bind_interface if bind_interface is not None else ''
 3715        '''
 3716         Bind interface
 3717        '''
 3718        self.database = database if database is not None else ''
 3719        self.egress_filter = egress_filter if egress_filter is not None else ''
 3720        '''
 3721         A filter applied to the routing logic to pin datasource to nodes.
 3722        '''
 3723        self.healthy = healthy if healthy is not None else False
 3724        '''
 3725         True if the datasource is reachable and the credentials are valid.
 3726        '''
 3727        self.hostname = hostname if hostname is not None else ''
 3728        self.id = id if id is not None else ''
 3729        '''
 3730         Unique identifier of the Resource.
 3731        '''
 3732        self.name = name if name is not None else ''
 3733        '''
 3734         Unique human-readable name of the Resource.
 3735        '''
 3736        self.override_database = override_database if override_database is not None else False
 3737        self.password = password if password is not None else ''
 3738        self.port = port if port is not None else 0
 3739        self.port_override = port_override if port_override is not None else 0
 3740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3741        '''
 3742         ID of the secret store containing credentials for this resource, if any.
 3743        '''
 3744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3745        '''
 3746         Tags is a map of key, value pairs.
 3747        '''
 3748        self.username = username if username is not None else ''
 3749
 3750    def __repr__(self):
 3751        return '<sdm.Cockroach ' + \
 3752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3753            'database: ' + repr(self.database) + ' ' +\
 3754            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3755            'healthy: ' + repr(self.healthy) + ' ' +\
 3756            'hostname: ' + repr(self.hostname) + ' ' +\
 3757            'id: ' + repr(self.id) + ' ' +\
 3758            'name: ' + repr(self.name) + ' ' +\
 3759            'override_database: ' + repr(self.override_database) + ' ' +\
 3760            'password: ' + repr(self.password) + ' ' +\
 3761            'port: ' + repr(self.port) + ' ' +\
 3762            'port_override: ' + repr(self.port_override) + ' ' +\
 3763            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3764            'tags: ' + repr(self.tags) + ' ' +\
 3765            'username: ' + repr(self.username) + ' ' +\
 3766            '>'
 3767
 3768    def to_dict(self):
 3769        return {
 3770            'bind_interface': self.bind_interface,
 3771            'database': self.database,
 3772            'egress_filter': self.egress_filter,
 3773            'healthy': self.healthy,
 3774            'hostname': self.hostname,
 3775            'id': self.id,
 3776            'name': self.name,
 3777            'override_database': self.override_database,
 3778            'password': self.password,
 3779            'port': self.port,
 3780            'port_override': self.port_override,
 3781            'secret_store_id': self.secret_store_id,
 3782            'tags': self.tags,
 3783            'username': self.username,
 3784        }
 3785
 3786    @classmethod
 3787    def from_dict(cls, d):
 3788        return cls(
 3789            bind_interface=d.get('bind_interface'),
 3790            database=d.get('database'),
 3791            egress_filter=d.get('egress_filter'),
 3792            healthy=d.get('healthy'),
 3793            hostname=d.get('hostname'),
 3794            id=d.get('id'),
 3795            name=d.get('name'),
 3796            override_database=d.get('override_database'),
 3797            password=d.get('password'),
 3798            port=d.get('port'),
 3799            port_override=d.get('port_override'),
 3800            secret_store_id=d.get('secret_store_id'),
 3801            tags=d.get('tags'),
 3802            username=d.get('username'),
 3803        )
 3804
 3805
 3806class ControlPanelGetSSHCAPublicKeyResponse:
 3807    '''
 3808         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3809     organization's SSH Certificate Authority public key.
 3810    '''
 3811    __slots__ = [
 3812        'meta',
 3813        'public_key',
 3814        'rate_limit',
 3815    ]
 3816
 3817    def __init__(
 3818        self,
 3819        meta=None,
 3820        public_key=None,
 3821        rate_limit=None,
 3822    ):
 3823        self.meta = meta if meta is not None else None
 3824        '''
 3825         Reserved for future use.
 3826        '''
 3827        self.public_key = public_key if public_key is not None else ''
 3828        '''
 3829         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3830         key format.
 3831        '''
 3832        self.rate_limit = rate_limit if rate_limit is not None else None
 3833        '''
 3834         Rate limit information.
 3835        '''
 3836
 3837    def __repr__(self):
 3838        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3839            'meta: ' + repr(self.meta) + ' ' +\
 3840            'public_key: ' + repr(self.public_key) + ' ' +\
 3841            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3842            '>'
 3843
 3844    def to_dict(self):
 3845        return {
 3846            'meta': self.meta,
 3847            'public_key': self.public_key,
 3848            'rate_limit': self.rate_limit,
 3849        }
 3850
 3851    @classmethod
 3852    def from_dict(cls, d):
 3853        return cls(
 3854            meta=d.get('meta'),
 3855            public_key=d.get('public_key'),
 3856            rate_limit=d.get('rate_limit'),
 3857        )
 3858
 3859
 3860class ControlPanelVerifyJWTResponse:
 3861    '''
 3862         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3863    '''
 3864    __slots__ = [
 3865        'meta',
 3866        'rate_limit',
 3867        'valid',
 3868    ]
 3869
 3870    def __init__(
 3871        self,
 3872        meta=None,
 3873        rate_limit=None,
 3874        valid=None,
 3875    ):
 3876        self.meta = meta if meta is not None else None
 3877        '''
 3878         Reserved for future use.
 3879        '''
 3880        self.rate_limit = rate_limit if rate_limit is not None else None
 3881        '''
 3882         Rate limit information.
 3883        '''
 3884        self.valid = valid if valid is not None else False
 3885        '''
 3886         Reports if the given token is valid.
 3887        '''
 3888
 3889    def __repr__(self):
 3890        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3891            'meta: ' + repr(self.meta) + ' ' +\
 3892            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3893            'valid: ' + repr(self.valid) + ' ' +\
 3894            '>'
 3895
 3896    def to_dict(self):
 3897        return {
 3898            'meta': self.meta,
 3899            'rate_limit': self.rate_limit,
 3900            'valid': self.valid,
 3901        }
 3902
 3903    @classmethod
 3904    def from_dict(cls, d):
 3905        return cls(
 3906            meta=d.get('meta'),
 3907            rate_limit=d.get('rate_limit'),
 3908            valid=d.get('valid'),
 3909        )
 3910
 3911
 3912class CreateResponseMetadata:
 3913    '''
 3914         CreateResponseMetadata is reserved for future use.
 3915    '''
 3916    __slots__ = []
 3917
 3918    def __init__(self, ):
 3919        pass
 3920
 3921    def __repr__(self):
 3922        return '<sdm.CreateResponseMetadata ' + \
 3923            '>'
 3924
 3925    def to_dict(self):
 3926        return {}
 3927
 3928    @classmethod
 3929    def from_dict(cls, d):
 3930        return cls()
 3931
 3932
 3933class CyberarkConjurStore:
 3934    '''
 3935    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
 3936    without a major version bump.
 3937    '''
 3938    __slots__ = [
 3939        'appurl',
 3940        'id',
 3941        'name',
 3942        'tags',
 3943    ]
 3944
 3945    def __init__(
 3946        self,
 3947        appurl=None,
 3948        id=None,
 3949        name=None,
 3950        tags=None,
 3951    ):
 3952        self.appurl = appurl if appurl is not None else ''
 3953        self.id = id if id is not None else ''
 3954        '''
 3955         Unique identifier of the SecretStore.
 3956        '''
 3957        self.name = name if name is not None else ''
 3958        '''
 3959         Unique human-readable name of the SecretStore.
 3960        '''
 3961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3962        '''
 3963         Tags is a map of key, value pairs.
 3964        '''
 3965
 3966    def __repr__(self):
 3967        return '<sdm.CyberarkConjurStore ' + \
 3968            'appurl: ' + repr(self.appurl) + ' ' +\
 3969            'id: ' + repr(self.id) + ' ' +\
 3970            'name: ' + repr(self.name) + ' ' +\
 3971            'tags: ' + repr(self.tags) + ' ' +\
 3972            '>'
 3973
 3974    def to_dict(self):
 3975        return {
 3976            'appurl': self.appurl,
 3977            'id': self.id,
 3978            'name': self.name,
 3979            'tags': self.tags,
 3980        }
 3981
 3982    @classmethod
 3983    def from_dict(cls, d):
 3984        return cls(
 3985            appurl=d.get('appurl'),
 3986            id=d.get('id'),
 3987            name=d.get('name'),
 3988            tags=d.get('tags'),
 3989        )
 3990
 3991
 3992class CyberarkPAMExperimentalStore:
 3993    '''
 3994    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
 3995    without a major version bump.
 3996    '''
 3997    __slots__ = [
 3998        'appurl',
 3999        'id',
 4000        'name',
 4001        'tags',
 4002    ]
 4003
 4004    def __init__(
 4005        self,
 4006        appurl=None,
 4007        id=None,
 4008        name=None,
 4009        tags=None,
 4010    ):
 4011        self.appurl = appurl if appurl is not None else ''
 4012        self.id = id if id is not None else ''
 4013        '''
 4014         Unique identifier of the SecretStore.
 4015        '''
 4016        self.name = name if name is not None else ''
 4017        '''
 4018         Unique human-readable name of the SecretStore.
 4019        '''
 4020        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4021        '''
 4022         Tags is a map of key, value pairs.
 4023        '''
 4024
 4025    def __repr__(self):
 4026        return '<sdm.CyberarkPAMExperimentalStore ' + \
 4027            'appurl: ' + repr(self.appurl) + ' ' +\
 4028            'id: ' + repr(self.id) + ' ' +\
 4029            'name: ' + repr(self.name) + ' ' +\
 4030            'tags: ' + repr(self.tags) + ' ' +\
 4031            '>'
 4032
 4033    def to_dict(self):
 4034        return {
 4035            'appurl': self.appurl,
 4036            'id': self.id,
 4037            'name': self.name,
 4038            'tags': self.tags,
 4039        }
 4040
 4041    @classmethod
 4042    def from_dict(cls, d):
 4043        return cls(
 4044            appurl=d.get('appurl'),
 4045            id=d.get('id'),
 4046            name=d.get('name'),
 4047            tags=d.get('tags'),
 4048        )
 4049
 4050
 4051class DB2I:
 4052    __slots__ = [
 4053        'bind_interface',
 4054        'egress_filter',
 4055        'healthy',
 4056        'hostname',
 4057        'id',
 4058        'name',
 4059        'password',
 4060        'port',
 4061        'port_override',
 4062        'secret_store_id',
 4063        'tags',
 4064        'tls_required',
 4065        'username',
 4066    ]
 4067
 4068    def __init__(
 4069        self,
 4070        bind_interface=None,
 4071        egress_filter=None,
 4072        healthy=None,
 4073        hostname=None,
 4074        id=None,
 4075        name=None,
 4076        password=None,
 4077        port=None,
 4078        port_override=None,
 4079        secret_store_id=None,
 4080        tags=None,
 4081        tls_required=None,
 4082        username=None,
 4083    ):
 4084        self.bind_interface = bind_interface if bind_interface is not None else ''
 4085        '''
 4086         Bind interface
 4087        '''
 4088        self.egress_filter = egress_filter if egress_filter is not None else ''
 4089        '''
 4090         A filter applied to the routing logic to pin datasource to nodes.
 4091        '''
 4092        self.healthy = healthy if healthy is not None else False
 4093        '''
 4094         True if the datasource is reachable and the credentials are valid.
 4095        '''
 4096        self.hostname = hostname if hostname is not None else ''
 4097        self.id = id if id is not None else ''
 4098        '''
 4099         Unique identifier of the Resource.
 4100        '''
 4101        self.name = name if name is not None else ''
 4102        '''
 4103         Unique human-readable name of the Resource.
 4104        '''
 4105        self.password = password if password is not None else ''
 4106        self.port = port if port is not None else 0
 4107        self.port_override = port_override if port_override is not None else 0
 4108        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4109        '''
 4110         ID of the secret store containing credentials for this resource, if any.
 4111        '''
 4112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4113        '''
 4114         Tags is a map of key, value pairs.
 4115        '''
 4116        self.tls_required = tls_required if tls_required is not None else False
 4117        self.username = username if username is not None else ''
 4118
 4119    def __repr__(self):
 4120        return '<sdm.DB2I ' + \
 4121            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4122            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4123            'healthy: ' + repr(self.healthy) + ' ' +\
 4124            'hostname: ' + repr(self.hostname) + ' ' +\
 4125            'id: ' + repr(self.id) + ' ' +\
 4126            'name: ' + repr(self.name) + ' ' +\
 4127            'password: ' + repr(self.password) + ' ' +\
 4128            'port: ' + repr(self.port) + ' ' +\
 4129            'port_override: ' + repr(self.port_override) + ' ' +\
 4130            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4131            'tags: ' + repr(self.tags) + ' ' +\
 4132            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4133            'username: ' + repr(self.username) + ' ' +\
 4134            '>'
 4135
 4136    def to_dict(self):
 4137        return {
 4138            'bind_interface': self.bind_interface,
 4139            'egress_filter': self.egress_filter,
 4140            'healthy': self.healthy,
 4141            'hostname': self.hostname,
 4142            'id': self.id,
 4143            'name': self.name,
 4144            'password': self.password,
 4145            'port': self.port,
 4146            'port_override': self.port_override,
 4147            'secret_store_id': self.secret_store_id,
 4148            'tags': self.tags,
 4149            'tls_required': self.tls_required,
 4150            'username': self.username,
 4151        }
 4152
 4153    @classmethod
 4154    def from_dict(cls, d):
 4155        return cls(
 4156            bind_interface=d.get('bind_interface'),
 4157            egress_filter=d.get('egress_filter'),
 4158            healthy=d.get('healthy'),
 4159            hostname=d.get('hostname'),
 4160            id=d.get('id'),
 4161            name=d.get('name'),
 4162            password=d.get('password'),
 4163            port=d.get('port'),
 4164            port_override=d.get('port_override'),
 4165            secret_store_id=d.get('secret_store_id'),
 4166            tags=d.get('tags'),
 4167            tls_required=d.get('tls_required'),
 4168            username=d.get('username'),
 4169        )
 4170
 4171
 4172class DB2LUW:
 4173    __slots__ = [
 4174        'bind_interface',
 4175        'database',
 4176        'egress_filter',
 4177        'healthy',
 4178        'hostname',
 4179        'id',
 4180        'name',
 4181        'password',
 4182        'port',
 4183        'port_override',
 4184        'secret_store_id',
 4185        'tags',
 4186        'username',
 4187    ]
 4188
 4189    def __init__(
 4190        self,
 4191        bind_interface=None,
 4192        database=None,
 4193        egress_filter=None,
 4194        healthy=None,
 4195        hostname=None,
 4196        id=None,
 4197        name=None,
 4198        password=None,
 4199        port=None,
 4200        port_override=None,
 4201        secret_store_id=None,
 4202        tags=None,
 4203        username=None,
 4204    ):
 4205        self.bind_interface = bind_interface if bind_interface is not None else ''
 4206        '''
 4207         Bind interface
 4208        '''
 4209        self.database = database if database is not None else ''
 4210        self.egress_filter = egress_filter if egress_filter is not None else ''
 4211        '''
 4212         A filter applied to the routing logic to pin datasource to nodes.
 4213        '''
 4214        self.healthy = healthy if healthy is not None else False
 4215        '''
 4216         True if the datasource is reachable and the credentials are valid.
 4217        '''
 4218        self.hostname = hostname if hostname is not None else ''
 4219        self.id = id if id is not None else ''
 4220        '''
 4221         Unique identifier of the Resource.
 4222        '''
 4223        self.name = name if name is not None else ''
 4224        '''
 4225         Unique human-readable name of the Resource.
 4226        '''
 4227        self.password = password if password is not None else ''
 4228        self.port = port if port is not None else 0
 4229        self.port_override = port_override if port_override is not None else 0
 4230        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4231        '''
 4232         ID of the secret store containing credentials for this resource, if any.
 4233        '''
 4234        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4235        '''
 4236         Tags is a map of key, value pairs.
 4237        '''
 4238        self.username = username if username is not None else ''
 4239
 4240    def __repr__(self):
 4241        return '<sdm.DB2LUW ' + \
 4242            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4243            'database: ' + repr(self.database) + ' ' +\
 4244            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4245            'healthy: ' + repr(self.healthy) + ' ' +\
 4246            'hostname: ' + repr(self.hostname) + ' ' +\
 4247            'id: ' + repr(self.id) + ' ' +\
 4248            'name: ' + repr(self.name) + ' ' +\
 4249            'password: ' + repr(self.password) + ' ' +\
 4250            'port: ' + repr(self.port) + ' ' +\
 4251            'port_override: ' + repr(self.port_override) + ' ' +\
 4252            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4253            'tags: ' + repr(self.tags) + ' ' +\
 4254            'username: ' + repr(self.username) + ' ' +\
 4255            '>'
 4256
 4257    def to_dict(self):
 4258        return {
 4259            'bind_interface': self.bind_interface,
 4260            'database': self.database,
 4261            'egress_filter': self.egress_filter,
 4262            'healthy': self.healthy,
 4263            'hostname': self.hostname,
 4264            'id': self.id,
 4265            'name': self.name,
 4266            'password': self.password,
 4267            'port': self.port,
 4268            'port_override': self.port_override,
 4269            'secret_store_id': self.secret_store_id,
 4270            'tags': self.tags,
 4271            'username': self.username,
 4272        }
 4273
 4274    @classmethod
 4275    def from_dict(cls, d):
 4276        return cls(
 4277            bind_interface=d.get('bind_interface'),
 4278            database=d.get('database'),
 4279            egress_filter=d.get('egress_filter'),
 4280            healthy=d.get('healthy'),
 4281            hostname=d.get('hostname'),
 4282            id=d.get('id'),
 4283            name=d.get('name'),
 4284            password=d.get('password'),
 4285            port=d.get('port'),
 4286            port_override=d.get('port_override'),
 4287            secret_store_id=d.get('secret_store_id'),
 4288            tags=d.get('tags'),
 4289            username=d.get('username'),
 4290        )
 4291
 4292
 4293class DeleteResponseMetadata:
 4294    '''
 4295         DeleteResponseMetadata is reserved for future use.
 4296    '''
 4297    __slots__ = []
 4298
 4299    def __init__(self, ):
 4300        pass
 4301
 4302    def __repr__(self):
 4303        return '<sdm.DeleteResponseMetadata ' + \
 4304            '>'
 4305
 4306    def to_dict(self):
 4307        return {}
 4308
 4309    @classmethod
 4310    def from_dict(cls, d):
 4311        return cls()
 4312
 4313
 4314class DelineaStore:
 4315    '''
 4316    DelineaStore is currently unstable, and its API may change, or it may be removed,
 4317    without a major version bump.
 4318    '''
 4319    __slots__ = [
 4320        'id',
 4321        'name',
 4322        'server_url',
 4323        'tags',
 4324        'tenant_name',
 4325    ]
 4326
 4327    def __init__(
 4328        self,
 4329        id=None,
 4330        name=None,
 4331        server_url=None,
 4332        tags=None,
 4333        tenant_name=None,
 4334    ):
 4335        self.id = id if id is not None else ''
 4336        '''
 4337         Unique identifier of the SecretStore.
 4338        '''
 4339        self.name = name if name is not None else ''
 4340        '''
 4341         Unique human-readable name of the SecretStore.
 4342        '''
 4343        self.server_url = server_url if server_url is not None else ''
 4344        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4345        '''
 4346         Tags is a map of key, value pairs.
 4347        '''
 4348        self.tenant_name = tenant_name if tenant_name is not None else ''
 4349
 4350    def __repr__(self):
 4351        return '<sdm.DelineaStore ' + \
 4352            'id: ' + repr(self.id) + ' ' +\
 4353            'name: ' + repr(self.name) + ' ' +\
 4354            'server_url: ' + repr(self.server_url) + ' ' +\
 4355            'tags: ' + repr(self.tags) + ' ' +\
 4356            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 4357            '>'
 4358
 4359    def to_dict(self):
 4360        return {
 4361            'id': self.id,
 4362            'name': self.name,
 4363            'server_url': self.server_url,
 4364            'tags': self.tags,
 4365            'tenant_name': self.tenant_name,
 4366        }
 4367
 4368    @classmethod
 4369    def from_dict(cls, d):
 4370        return cls(
 4371            id=d.get('id'),
 4372            name=d.get('name'),
 4373            server_url=d.get('server_url'),
 4374            tags=d.get('tags'),
 4375            tenant_name=d.get('tenant_name'),
 4376        )
 4377
 4378
 4379class DocumentDBHost:
 4380    __slots__ = [
 4381        'auth_database',
 4382        'bind_interface',
 4383        'egress_filter',
 4384        'healthy',
 4385        'hostname',
 4386        'id',
 4387        'name',
 4388        'password',
 4389        'port',
 4390        'port_override',
 4391        'secret_store_id',
 4392        'tags',
 4393        'username',
 4394    ]
 4395
 4396    def __init__(
 4397        self,
 4398        auth_database=None,
 4399        bind_interface=None,
 4400        egress_filter=None,
 4401        healthy=None,
 4402        hostname=None,
 4403        id=None,
 4404        name=None,
 4405        password=None,
 4406        port=None,
 4407        port_override=None,
 4408        secret_store_id=None,
 4409        tags=None,
 4410        username=None,
 4411    ):
 4412        self.auth_database = auth_database if auth_database is not None else ''
 4413        self.bind_interface = bind_interface if bind_interface is not None else ''
 4414        '''
 4415         Bind interface
 4416        '''
 4417        self.egress_filter = egress_filter if egress_filter is not None else ''
 4418        '''
 4419         A filter applied to the routing logic to pin datasource to nodes.
 4420        '''
 4421        self.healthy = healthy if healthy is not None else False
 4422        '''
 4423         True if the datasource is reachable and the credentials are valid.
 4424        '''
 4425        self.hostname = hostname if hostname is not None else ''
 4426        self.id = id if id is not None else ''
 4427        '''
 4428         Unique identifier of the Resource.
 4429        '''
 4430        self.name = name if name is not None else ''
 4431        '''
 4432         Unique human-readable name of the Resource.
 4433        '''
 4434        self.password = password if password is not None else ''
 4435        self.port = port if port is not None else 0
 4436        self.port_override = port_override if port_override is not None else 0
 4437        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4438        '''
 4439         ID of the secret store containing credentials for this resource, if any.
 4440        '''
 4441        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4442        '''
 4443         Tags is a map of key, value pairs.
 4444        '''
 4445        self.username = username if username is not None else ''
 4446
 4447    def __repr__(self):
 4448        return '<sdm.DocumentDBHost ' + \
 4449            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4450            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4451            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4452            'healthy: ' + repr(self.healthy) + ' ' +\
 4453            'hostname: ' + repr(self.hostname) + ' ' +\
 4454            'id: ' + repr(self.id) + ' ' +\
 4455            'name: ' + repr(self.name) + ' ' +\
 4456            'password: ' + repr(self.password) + ' ' +\
 4457            'port: ' + repr(self.port) + ' ' +\
 4458            'port_override: ' + repr(self.port_override) + ' ' +\
 4459            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4460            'tags: ' + repr(self.tags) + ' ' +\
 4461            'username: ' + repr(self.username) + ' ' +\
 4462            '>'
 4463
 4464    def to_dict(self):
 4465        return {
 4466            'auth_database': self.auth_database,
 4467            'bind_interface': self.bind_interface,
 4468            'egress_filter': self.egress_filter,
 4469            'healthy': self.healthy,
 4470            'hostname': self.hostname,
 4471            'id': self.id,
 4472            'name': self.name,
 4473            'password': self.password,
 4474            'port': self.port,
 4475            'port_override': self.port_override,
 4476            'secret_store_id': self.secret_store_id,
 4477            'tags': self.tags,
 4478            'username': self.username,
 4479        }
 4480
 4481    @classmethod
 4482    def from_dict(cls, d):
 4483        return cls(
 4484            auth_database=d.get('auth_database'),
 4485            bind_interface=d.get('bind_interface'),
 4486            egress_filter=d.get('egress_filter'),
 4487            healthy=d.get('healthy'),
 4488            hostname=d.get('hostname'),
 4489            id=d.get('id'),
 4490            name=d.get('name'),
 4491            password=d.get('password'),
 4492            port=d.get('port'),
 4493            port_override=d.get('port_override'),
 4494            secret_store_id=d.get('secret_store_id'),
 4495            tags=d.get('tags'),
 4496            username=d.get('username'),
 4497        )
 4498
 4499
 4500class DocumentDBReplicaSet:
 4501    __slots__ = [
 4502        'auth_database',
 4503        'bind_interface',
 4504        'connect_to_replica',
 4505        'egress_filter',
 4506        'healthy',
 4507        'hostname',
 4508        'id',
 4509        'name',
 4510        'password',
 4511        'port_override',
 4512        'replica_set',
 4513        'secret_store_id',
 4514        'tags',
 4515        'username',
 4516    ]
 4517
 4518    def __init__(
 4519        self,
 4520        auth_database=None,
 4521        bind_interface=None,
 4522        connect_to_replica=None,
 4523        egress_filter=None,
 4524        healthy=None,
 4525        hostname=None,
 4526        id=None,
 4527        name=None,
 4528        password=None,
 4529        port_override=None,
 4530        replica_set=None,
 4531        secret_store_id=None,
 4532        tags=None,
 4533        username=None,
 4534    ):
 4535        self.auth_database = auth_database if auth_database is not None else ''
 4536        self.bind_interface = bind_interface if bind_interface is not None else ''
 4537        '''
 4538         Bind interface
 4539        '''
 4540        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4541        self.egress_filter = egress_filter if egress_filter is not None else ''
 4542        '''
 4543         A filter applied to the routing logic to pin datasource to nodes.
 4544        '''
 4545        self.healthy = healthy if healthy is not None else False
 4546        '''
 4547         True if the datasource is reachable and the credentials are valid.
 4548        '''
 4549        self.hostname = hostname if hostname is not None else ''
 4550        '''
 4551         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4552        '''
 4553        self.id = id if id is not None else ''
 4554        '''
 4555         Unique identifier of the Resource.
 4556        '''
 4557        self.name = name if name is not None else ''
 4558        '''
 4559         Unique human-readable name of the Resource.
 4560        '''
 4561        self.password = password if password is not None else ''
 4562        self.port_override = port_override if port_override is not None else 0
 4563        self.replica_set = replica_set if replica_set is not None else ''
 4564        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4565        '''
 4566         ID of the secret store containing credentials for this resource, if any.
 4567        '''
 4568        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4569        '''
 4570         Tags is a map of key, value pairs.
 4571        '''
 4572        self.username = username if username is not None else ''
 4573
 4574    def __repr__(self):
 4575        return '<sdm.DocumentDBReplicaSet ' + \
 4576            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4577            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4578            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4579            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4580            'healthy: ' + repr(self.healthy) + ' ' +\
 4581            'hostname: ' + repr(self.hostname) + ' ' +\
 4582            'id: ' + repr(self.id) + ' ' +\
 4583            'name: ' + repr(self.name) + ' ' +\
 4584            'password: ' + repr(self.password) + ' ' +\
 4585            'port_override: ' + repr(self.port_override) + ' ' +\
 4586            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4587            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4588            'tags: ' + repr(self.tags) + ' ' +\
 4589            'username: ' + repr(self.username) + ' ' +\
 4590            '>'
 4591
 4592    def to_dict(self):
 4593        return {
 4594            'auth_database': self.auth_database,
 4595            'bind_interface': self.bind_interface,
 4596            'connect_to_replica': self.connect_to_replica,
 4597            'egress_filter': self.egress_filter,
 4598            'healthy': self.healthy,
 4599            'hostname': self.hostname,
 4600            'id': self.id,
 4601            'name': self.name,
 4602            'password': self.password,
 4603            'port_override': self.port_override,
 4604            'replica_set': self.replica_set,
 4605            'secret_store_id': self.secret_store_id,
 4606            'tags': self.tags,
 4607            'username': self.username,
 4608        }
 4609
 4610    @classmethod
 4611    def from_dict(cls, d):
 4612        return cls(
 4613            auth_database=d.get('auth_database'),
 4614            bind_interface=d.get('bind_interface'),
 4615            connect_to_replica=d.get('connect_to_replica'),
 4616            egress_filter=d.get('egress_filter'),
 4617            healthy=d.get('healthy'),
 4618            hostname=d.get('hostname'),
 4619            id=d.get('id'),
 4620            name=d.get('name'),
 4621            password=d.get('password'),
 4622            port_override=d.get('port_override'),
 4623            replica_set=d.get('replica_set'),
 4624            secret_store_id=d.get('secret_store_id'),
 4625            tags=d.get('tags'),
 4626            username=d.get('username'),
 4627        )
 4628
 4629
 4630class Druid:
 4631    __slots__ = [
 4632        'bind_interface',
 4633        'egress_filter',
 4634        'healthy',
 4635        'hostname',
 4636        'id',
 4637        'name',
 4638        'password',
 4639        'port',
 4640        'port_override',
 4641        'secret_store_id',
 4642        'tags',
 4643        'username',
 4644    ]
 4645
 4646    def __init__(
 4647        self,
 4648        bind_interface=None,
 4649        egress_filter=None,
 4650        healthy=None,
 4651        hostname=None,
 4652        id=None,
 4653        name=None,
 4654        password=None,
 4655        port=None,
 4656        port_override=None,
 4657        secret_store_id=None,
 4658        tags=None,
 4659        username=None,
 4660    ):
 4661        self.bind_interface = bind_interface if bind_interface is not None else ''
 4662        '''
 4663         Bind interface
 4664        '''
 4665        self.egress_filter = egress_filter if egress_filter is not None else ''
 4666        '''
 4667         A filter applied to the routing logic to pin datasource to nodes.
 4668        '''
 4669        self.healthy = healthy if healthy is not None else False
 4670        '''
 4671         True if the datasource is reachable and the credentials are valid.
 4672        '''
 4673        self.hostname = hostname if hostname is not None else ''
 4674        self.id = id if id is not None else ''
 4675        '''
 4676         Unique identifier of the Resource.
 4677        '''
 4678        self.name = name if name is not None else ''
 4679        '''
 4680         Unique human-readable name of the Resource.
 4681        '''
 4682        self.password = password if password is not None else ''
 4683        self.port = port if port is not None else 0
 4684        self.port_override = port_override if port_override is not None else 0
 4685        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4686        '''
 4687         ID of the secret store containing credentials for this resource, if any.
 4688        '''
 4689        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4690        '''
 4691         Tags is a map of key, value pairs.
 4692        '''
 4693        self.username = username if username is not None else ''
 4694
 4695    def __repr__(self):
 4696        return '<sdm.Druid ' + \
 4697            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4698            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4699            'healthy: ' + repr(self.healthy) + ' ' +\
 4700            'hostname: ' + repr(self.hostname) + ' ' +\
 4701            'id: ' + repr(self.id) + ' ' +\
 4702            'name: ' + repr(self.name) + ' ' +\
 4703            'password: ' + repr(self.password) + ' ' +\
 4704            'port: ' + repr(self.port) + ' ' +\
 4705            'port_override: ' + repr(self.port_override) + ' ' +\
 4706            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4707            'tags: ' + repr(self.tags) + ' ' +\
 4708            'username: ' + repr(self.username) + ' ' +\
 4709            '>'
 4710
 4711    def to_dict(self):
 4712        return {
 4713            'bind_interface': self.bind_interface,
 4714            'egress_filter': self.egress_filter,
 4715            'healthy': self.healthy,
 4716            'hostname': self.hostname,
 4717            'id': self.id,
 4718            'name': self.name,
 4719            'password': self.password,
 4720            'port': self.port,
 4721            'port_override': self.port_override,
 4722            'secret_store_id': self.secret_store_id,
 4723            'tags': self.tags,
 4724            'username': self.username,
 4725        }
 4726
 4727    @classmethod
 4728    def from_dict(cls, d):
 4729        return cls(
 4730            bind_interface=d.get('bind_interface'),
 4731            egress_filter=d.get('egress_filter'),
 4732            healthy=d.get('healthy'),
 4733            hostname=d.get('hostname'),
 4734            id=d.get('id'),
 4735            name=d.get('name'),
 4736            password=d.get('password'),
 4737            port=d.get('port'),
 4738            port_override=d.get('port_override'),
 4739            secret_store_id=d.get('secret_store_id'),
 4740            tags=d.get('tags'),
 4741            username=d.get('username'),
 4742        )
 4743
 4744
 4745class DynamoDB:
 4746    __slots__ = [
 4747        'access_key',
 4748        'bind_interface',
 4749        'egress_filter',
 4750        'endpoint',
 4751        'healthy',
 4752        'id',
 4753        'name',
 4754        'port_override',
 4755        'region',
 4756        'role_arn',
 4757        'role_external_id',
 4758        'secret_access_key',
 4759        'secret_store_id',
 4760        'tags',
 4761    ]
 4762
 4763    def __init__(
 4764        self,
 4765        access_key=None,
 4766        bind_interface=None,
 4767        egress_filter=None,
 4768        endpoint=None,
 4769        healthy=None,
 4770        id=None,
 4771        name=None,
 4772        port_override=None,
 4773        region=None,
 4774        role_arn=None,
 4775        role_external_id=None,
 4776        secret_access_key=None,
 4777        secret_store_id=None,
 4778        tags=None,
 4779    ):
 4780        self.access_key = access_key if access_key is not None else ''
 4781        self.bind_interface = bind_interface if bind_interface is not None else ''
 4782        '''
 4783         Bind interface
 4784        '''
 4785        self.egress_filter = egress_filter if egress_filter is not None else ''
 4786        '''
 4787         A filter applied to the routing logic to pin datasource to nodes.
 4788        '''
 4789        self.endpoint = endpoint if endpoint is not None else ''
 4790        self.healthy = healthy if healthy is not None else False
 4791        '''
 4792         True if the datasource is reachable and the credentials are valid.
 4793        '''
 4794        self.id = id if id is not None else ''
 4795        '''
 4796         Unique identifier of the Resource.
 4797        '''
 4798        self.name = name if name is not None else ''
 4799        '''
 4800         Unique human-readable name of the Resource.
 4801        '''
 4802        self.port_override = port_override if port_override is not None else 0
 4803        self.region = region if region is not None else ''
 4804        self.role_arn = role_arn if role_arn is not None else ''
 4805        self.role_external_id = role_external_id if role_external_id is not None else ''
 4806        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4807        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4808        '''
 4809         ID of the secret store containing credentials for this resource, if any.
 4810        '''
 4811        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4812        '''
 4813         Tags is a map of key, value pairs.
 4814        '''
 4815
 4816    def __repr__(self):
 4817        return '<sdm.DynamoDB ' + \
 4818            'access_key: ' + repr(self.access_key) + ' ' +\
 4819            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4820            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4821            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4822            'healthy: ' + repr(self.healthy) + ' ' +\
 4823            'id: ' + repr(self.id) + ' ' +\
 4824            'name: ' + repr(self.name) + ' ' +\
 4825            'port_override: ' + repr(self.port_override) + ' ' +\
 4826            'region: ' + repr(self.region) + ' ' +\
 4827            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4828            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4829            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4830            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4831            'tags: ' + repr(self.tags) + ' ' +\
 4832            '>'
 4833
 4834    def to_dict(self):
 4835        return {
 4836            'access_key': self.access_key,
 4837            'bind_interface': self.bind_interface,
 4838            'egress_filter': self.egress_filter,
 4839            'endpoint': self.endpoint,
 4840            'healthy': self.healthy,
 4841            'id': self.id,
 4842            'name': self.name,
 4843            'port_override': self.port_override,
 4844            'region': self.region,
 4845            'role_arn': self.role_arn,
 4846            'role_external_id': self.role_external_id,
 4847            'secret_access_key': self.secret_access_key,
 4848            'secret_store_id': self.secret_store_id,
 4849            'tags': self.tags,
 4850        }
 4851
 4852    @classmethod
 4853    def from_dict(cls, d):
 4854        return cls(
 4855            access_key=d.get('access_key'),
 4856            bind_interface=d.get('bind_interface'),
 4857            egress_filter=d.get('egress_filter'),
 4858            endpoint=d.get('endpoint'),
 4859            healthy=d.get('healthy'),
 4860            id=d.get('id'),
 4861            name=d.get('name'),
 4862            port_override=d.get('port_override'),
 4863            region=d.get('region'),
 4864            role_arn=d.get('role_arn'),
 4865            role_external_id=d.get('role_external_id'),
 4866            secret_access_key=d.get('secret_access_key'),
 4867            secret_store_id=d.get('secret_store_id'),
 4868            tags=d.get('tags'),
 4869        )
 4870
 4871
 4872class Elastic:
 4873    __slots__ = [
 4874        'bind_interface',
 4875        'egress_filter',
 4876        'healthy',
 4877        'hostname',
 4878        'id',
 4879        'name',
 4880        'password',
 4881        'port',
 4882        'port_override',
 4883        'secret_store_id',
 4884        'tags',
 4885        'tls_required',
 4886        'username',
 4887    ]
 4888
 4889    def __init__(
 4890        self,
 4891        bind_interface=None,
 4892        egress_filter=None,
 4893        healthy=None,
 4894        hostname=None,
 4895        id=None,
 4896        name=None,
 4897        password=None,
 4898        port=None,
 4899        port_override=None,
 4900        secret_store_id=None,
 4901        tags=None,
 4902        tls_required=None,
 4903        username=None,
 4904    ):
 4905        self.bind_interface = bind_interface if bind_interface is not None else ''
 4906        '''
 4907         Bind interface
 4908        '''
 4909        self.egress_filter = egress_filter if egress_filter is not None else ''
 4910        '''
 4911         A filter applied to the routing logic to pin datasource to nodes.
 4912        '''
 4913        self.healthy = healthy if healthy is not None else False
 4914        '''
 4915         True if the datasource is reachable and the credentials are valid.
 4916        '''
 4917        self.hostname = hostname if hostname is not None else ''
 4918        self.id = id if id is not None else ''
 4919        '''
 4920         Unique identifier of the Resource.
 4921        '''
 4922        self.name = name if name is not None else ''
 4923        '''
 4924         Unique human-readable name of the Resource.
 4925        '''
 4926        self.password = password if password is not None else ''
 4927        self.port = port if port is not None else 0
 4928        self.port_override = port_override if port_override is not None else 0
 4929        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4930        '''
 4931         ID of the secret store containing credentials for this resource, if any.
 4932        '''
 4933        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4934        '''
 4935         Tags is a map of key, value pairs.
 4936        '''
 4937        self.tls_required = tls_required if tls_required is not None else False
 4938        self.username = username if username is not None else ''
 4939
 4940    def __repr__(self):
 4941        return '<sdm.Elastic ' + \
 4942            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4943            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4944            'healthy: ' + repr(self.healthy) + ' ' +\
 4945            'hostname: ' + repr(self.hostname) + ' ' +\
 4946            'id: ' + repr(self.id) + ' ' +\
 4947            'name: ' + repr(self.name) + ' ' +\
 4948            'password: ' + repr(self.password) + ' ' +\
 4949            'port: ' + repr(self.port) + ' ' +\
 4950            'port_override: ' + repr(self.port_override) + ' ' +\
 4951            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4952            'tags: ' + repr(self.tags) + ' ' +\
 4953            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4954            'username: ' + repr(self.username) + ' ' +\
 4955            '>'
 4956
 4957    def to_dict(self):
 4958        return {
 4959            'bind_interface': self.bind_interface,
 4960            'egress_filter': self.egress_filter,
 4961            'healthy': self.healthy,
 4962            'hostname': self.hostname,
 4963            'id': self.id,
 4964            'name': self.name,
 4965            'password': self.password,
 4966            'port': self.port,
 4967            'port_override': self.port_override,
 4968            'secret_store_id': self.secret_store_id,
 4969            'tags': self.tags,
 4970            'tls_required': self.tls_required,
 4971            'username': self.username,
 4972        }
 4973
 4974    @classmethod
 4975    def from_dict(cls, d):
 4976        return cls(
 4977            bind_interface=d.get('bind_interface'),
 4978            egress_filter=d.get('egress_filter'),
 4979            healthy=d.get('healthy'),
 4980            hostname=d.get('hostname'),
 4981            id=d.get('id'),
 4982            name=d.get('name'),
 4983            password=d.get('password'),
 4984            port=d.get('port'),
 4985            port_override=d.get('port_override'),
 4986            secret_store_id=d.get('secret_store_id'),
 4987            tags=d.get('tags'),
 4988            tls_required=d.get('tls_required'),
 4989            username=d.get('username'),
 4990        )
 4991
 4992
 4993class ElasticacheRedis:
 4994    __slots__ = [
 4995        'bind_interface',
 4996        'egress_filter',
 4997        'healthy',
 4998        'hostname',
 4999        'id',
 5000        'name',
 5001        'password',
 5002        'port',
 5003        'port_override',
 5004        'secret_store_id',
 5005        'tags',
 5006        'tls_required',
 5007    ]
 5008
 5009    def __init__(
 5010        self,
 5011        bind_interface=None,
 5012        egress_filter=None,
 5013        healthy=None,
 5014        hostname=None,
 5015        id=None,
 5016        name=None,
 5017        password=None,
 5018        port=None,
 5019        port_override=None,
 5020        secret_store_id=None,
 5021        tags=None,
 5022        tls_required=None,
 5023    ):
 5024        self.bind_interface = bind_interface if bind_interface is not None else ''
 5025        '''
 5026         Bind interface
 5027        '''
 5028        self.egress_filter = egress_filter if egress_filter is not None else ''
 5029        '''
 5030         A filter applied to the routing logic to pin datasource to nodes.
 5031        '''
 5032        self.healthy = healthy if healthy is not None else False
 5033        '''
 5034         True if the datasource is reachable and the credentials are valid.
 5035        '''
 5036        self.hostname = hostname if hostname is not None else ''
 5037        self.id = id if id is not None else ''
 5038        '''
 5039         Unique identifier of the Resource.
 5040        '''
 5041        self.name = name if name is not None else ''
 5042        '''
 5043         Unique human-readable name of the Resource.
 5044        '''
 5045        self.password = password if password is not None else ''
 5046        self.port = port if port is not None else 0
 5047        self.port_override = port_override if port_override is not None else 0
 5048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5049        '''
 5050         ID of the secret store containing credentials for this resource, if any.
 5051        '''
 5052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5053        '''
 5054         Tags is a map of key, value pairs.
 5055        '''
 5056        self.tls_required = tls_required if tls_required is not None else False
 5057
 5058    def __repr__(self):
 5059        return '<sdm.ElasticacheRedis ' + \
 5060            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5061            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5062            'healthy: ' + repr(self.healthy) + ' ' +\
 5063            'hostname: ' + repr(self.hostname) + ' ' +\
 5064            'id: ' + repr(self.id) + ' ' +\
 5065            'name: ' + repr(self.name) + ' ' +\
 5066            'password: ' + repr(self.password) + ' ' +\
 5067            'port: ' + repr(self.port) + ' ' +\
 5068            'port_override: ' + repr(self.port_override) + ' ' +\
 5069            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5070            'tags: ' + repr(self.tags) + ' ' +\
 5071            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5072            '>'
 5073
 5074    def to_dict(self):
 5075        return {
 5076            'bind_interface': self.bind_interface,
 5077            'egress_filter': self.egress_filter,
 5078            'healthy': self.healthy,
 5079            'hostname': self.hostname,
 5080            'id': self.id,
 5081            'name': self.name,
 5082            'password': self.password,
 5083            'port': self.port,
 5084            'port_override': self.port_override,
 5085            'secret_store_id': self.secret_store_id,
 5086            'tags': self.tags,
 5087            'tls_required': self.tls_required,
 5088        }
 5089
 5090    @classmethod
 5091    def from_dict(cls, d):
 5092        return cls(
 5093            bind_interface=d.get('bind_interface'),
 5094            egress_filter=d.get('egress_filter'),
 5095            healthy=d.get('healthy'),
 5096            hostname=d.get('hostname'),
 5097            id=d.get('id'),
 5098            name=d.get('name'),
 5099            password=d.get('password'),
 5100            port=d.get('port'),
 5101            port_override=d.get('port_override'),
 5102            secret_store_id=d.get('secret_store_id'),
 5103            tags=d.get('tags'),
 5104            tls_required=d.get('tls_required'),
 5105        )
 5106
 5107
 5108class GCP:
 5109    __slots__ = [
 5110        'bind_interface',
 5111        'egress_filter',
 5112        'healthy',
 5113        'id',
 5114        'keyfile',
 5115        'name',
 5116        'scopes',
 5117        'secret_store_id',
 5118        'tags',
 5119    ]
 5120
 5121    def __init__(
 5122        self,
 5123        bind_interface=None,
 5124        egress_filter=None,
 5125        healthy=None,
 5126        id=None,
 5127        keyfile=None,
 5128        name=None,
 5129        scopes=None,
 5130        secret_store_id=None,
 5131        tags=None,
 5132    ):
 5133        self.bind_interface = bind_interface if bind_interface is not None else ''
 5134        '''
 5135         Bind interface
 5136        '''
 5137        self.egress_filter = egress_filter if egress_filter is not None else ''
 5138        '''
 5139         A filter applied to the routing logic to pin datasource to nodes.
 5140        '''
 5141        self.healthy = healthy if healthy is not None else False
 5142        '''
 5143         True if the datasource is reachable and the credentials are valid.
 5144        '''
 5145        self.id = id if id is not None else ''
 5146        '''
 5147         Unique identifier of the Resource.
 5148        '''
 5149        self.keyfile = keyfile if keyfile is not None else ''
 5150        self.name = name if name is not None else ''
 5151        '''
 5152         Unique human-readable name of the Resource.
 5153        '''
 5154        self.scopes = scopes if scopes is not None else ''
 5155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5156        '''
 5157         ID of the secret store containing credentials for this resource, if any.
 5158        '''
 5159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5160        '''
 5161         Tags is a map of key, value pairs.
 5162        '''
 5163
 5164    def __repr__(self):
 5165        return '<sdm.GCP ' + \
 5166            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5167            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5168            'healthy: ' + repr(self.healthy) + ' ' +\
 5169            'id: ' + repr(self.id) + ' ' +\
 5170            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5171            'name: ' + repr(self.name) + ' ' +\
 5172            'scopes: ' + repr(self.scopes) + ' ' +\
 5173            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5174            'tags: ' + repr(self.tags) + ' ' +\
 5175            '>'
 5176
 5177    def to_dict(self):
 5178        return {
 5179            'bind_interface': self.bind_interface,
 5180            'egress_filter': self.egress_filter,
 5181            'healthy': self.healthy,
 5182            'id': self.id,
 5183            'keyfile': self.keyfile,
 5184            'name': self.name,
 5185            'scopes': self.scopes,
 5186            'secret_store_id': self.secret_store_id,
 5187            'tags': self.tags,
 5188        }
 5189
 5190    @classmethod
 5191    def from_dict(cls, d):
 5192        return cls(
 5193            bind_interface=d.get('bind_interface'),
 5194            egress_filter=d.get('egress_filter'),
 5195            healthy=d.get('healthy'),
 5196            id=d.get('id'),
 5197            keyfile=d.get('keyfile'),
 5198            name=d.get('name'),
 5199            scopes=d.get('scopes'),
 5200            secret_store_id=d.get('secret_store_id'),
 5201            tags=d.get('tags'),
 5202        )
 5203
 5204
 5205class GCPStore:
 5206    __slots__ = [
 5207        'id',
 5208        'name',
 5209        'projectid',
 5210        'tags',
 5211    ]
 5212
 5213    def __init__(
 5214        self,
 5215        id=None,
 5216        name=None,
 5217        projectid=None,
 5218        tags=None,
 5219    ):
 5220        self.id = id if id is not None else ''
 5221        '''
 5222         Unique identifier of the SecretStore.
 5223        '''
 5224        self.name = name if name is not None else ''
 5225        '''
 5226         Unique human-readable name of the SecretStore.
 5227        '''
 5228        self.projectid = projectid if projectid is not None else ''
 5229        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5230        '''
 5231         Tags is a map of key, value pairs.
 5232        '''
 5233
 5234    def __repr__(self):
 5235        return '<sdm.GCPStore ' + \
 5236            'id: ' + repr(self.id) + ' ' +\
 5237            'name: ' + repr(self.name) + ' ' +\
 5238            'projectid: ' + repr(self.projectid) + ' ' +\
 5239            'tags: ' + repr(self.tags) + ' ' +\
 5240            '>'
 5241
 5242    def to_dict(self):
 5243        return {
 5244            'id': self.id,
 5245            'name': self.name,
 5246            'projectid': self.projectid,
 5247            'tags': self.tags,
 5248        }
 5249
 5250    @classmethod
 5251    def from_dict(cls, d):
 5252        return cls(
 5253            id=d.get('id'),
 5254            name=d.get('name'),
 5255            projectid=d.get('projectid'),
 5256            tags=d.get('tags'),
 5257        )
 5258
 5259
 5260class Gateway:
 5261    '''
 5262         Gateway represents a StrongDM CLI installation running in gateway mode.
 5263    '''
 5264    __slots__ = [
 5265        'bind_address',
 5266        'device',
 5267        'gateway_filter',
 5268        'id',
 5269        'listen_address',
 5270        'location',
 5271        'name',
 5272        'state',
 5273        'tags',
 5274        'version',
 5275    ]
 5276
 5277    def __init__(
 5278        self,
 5279        bind_address=None,
 5280        device=None,
 5281        gateway_filter=None,
 5282        id=None,
 5283        listen_address=None,
 5284        location=None,
 5285        name=None,
 5286        state=None,
 5287        tags=None,
 5288        version=None,
 5289    ):
 5290        self.bind_address = bind_address if bind_address is not None else ''
 5291        '''
 5292         The hostname/port tuple which the gateway daemon will bind to.
 5293         If not provided on create, set to "0.0.0.0:listen_address_port".
 5294        '''
 5295        self.device = device if device is not None else ''
 5296        '''
 5297         Device is a read only device name uploaded by the gateway process when 
 5298         it comes online.
 5299        '''
 5300        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5301        '''
 5302         GatewayFilter can be used to restrict the peering between relays and
 5303         gateways.
 5304        '''
 5305        self.id = id if id is not None else ''
 5306        '''
 5307         Unique identifier of the Gateway.
 5308        '''
 5309        self.listen_address = listen_address if listen_address is not None else ''
 5310        '''
 5311         The public hostname/port tuple at which the gateway will be accessible to clients.
 5312        '''
 5313        self.location = location if location is not None else ''
 5314        '''
 5315         Location is a read only network location uploaded by the gateway process
 5316         when it comes online.
 5317        '''
 5318        self.name = name if name is not None else ''
 5319        '''
 5320         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5321        '''
 5322        self.state = state if state is not None else ''
 5323        '''
 5324         The current state of the gateway. One of: "new", "verifying_restart",
 5325         "restarting", "started", "stopped", "dead", "unknown"
 5326        '''
 5327        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5328        '''
 5329         Tags is a map of key, value pairs.
 5330        '''
 5331        self.version = version if version is not None else ''
 5332        '''
 5333         Version is a read only sdm binary version uploaded by the gateway process
 5334         when it comes online.
 5335        '''
 5336
 5337    def __repr__(self):
 5338        return '<sdm.Gateway ' + \
 5339            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5340            'device: ' + repr(self.device) + ' ' +\
 5341            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5342            'id: ' + repr(self.id) + ' ' +\
 5343            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5344            'location: ' + repr(self.location) + ' ' +\
 5345            'name: ' + repr(self.name) + ' ' +\
 5346            'state: ' + repr(self.state) + ' ' +\
 5347            'tags: ' + repr(self.tags) + ' ' +\
 5348            'version: ' + repr(self.version) + ' ' +\
 5349            '>'
 5350
 5351    def to_dict(self):
 5352        return {
 5353            'bind_address': self.bind_address,
 5354            'device': self.device,
 5355            'gateway_filter': self.gateway_filter,
 5356            'id': self.id,
 5357            'listen_address': self.listen_address,
 5358            'location': self.location,
 5359            'name': self.name,
 5360            'state': self.state,
 5361            'tags': self.tags,
 5362            'version': self.version,
 5363        }
 5364
 5365    @classmethod
 5366    def from_dict(cls, d):
 5367        return cls(
 5368            bind_address=d.get('bind_address'),
 5369            device=d.get('device'),
 5370            gateway_filter=d.get('gateway_filter'),
 5371            id=d.get('id'),
 5372            listen_address=d.get('listen_address'),
 5373            location=d.get('location'),
 5374            name=d.get('name'),
 5375            state=d.get('state'),
 5376            tags=d.get('tags'),
 5377            version=d.get('version'),
 5378        )
 5379
 5380
 5381class GetResponseMetadata:
 5382    '''
 5383         GetResponseMetadata is reserved for future use.
 5384    '''
 5385    __slots__ = []
 5386
 5387    def __init__(self, ):
 5388        pass
 5389
 5390    def __repr__(self):
 5391        return '<sdm.GetResponseMetadata ' + \
 5392            '>'
 5393
 5394    def to_dict(self):
 5395        return {}
 5396
 5397    @classmethod
 5398    def from_dict(cls, d):
 5399        return cls()
 5400
 5401
 5402class GoogleGKE:
 5403    __slots__ = [
 5404        'bind_interface',
 5405        'certificate_authority',
 5406        'egress_filter',
 5407        'endpoint',
 5408        'healthcheck_namespace',
 5409        'healthy',
 5410        'id',
 5411        'name',
 5412        'remote_identity_group_id',
 5413        'remote_identity_healthcheck_username',
 5414        'secret_store_id',
 5415        'service_account_key',
 5416        'tags',
 5417    ]
 5418
 5419    def __init__(
 5420        self,
 5421        bind_interface=None,
 5422        certificate_authority=None,
 5423        egress_filter=None,
 5424        endpoint=None,
 5425        healthcheck_namespace=None,
 5426        healthy=None,
 5427        id=None,
 5428        name=None,
 5429        remote_identity_group_id=None,
 5430        remote_identity_healthcheck_username=None,
 5431        secret_store_id=None,
 5432        service_account_key=None,
 5433        tags=None,
 5434    ):
 5435        self.bind_interface = bind_interface if bind_interface is not None else ''
 5436        '''
 5437         Bind interface
 5438        '''
 5439        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5440        self.egress_filter = egress_filter if egress_filter is not None else ''
 5441        '''
 5442         A filter applied to the routing logic to pin datasource to nodes.
 5443        '''
 5444        self.endpoint = endpoint if endpoint is not None else ''
 5445        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5446        '''
 5447         The path used to check the health of your connection.  Defaults to `default`.
 5448        '''
 5449        self.healthy = healthy if healthy is not None else False
 5450        '''
 5451         True if the datasource is reachable and the credentials are valid.
 5452        '''
 5453        self.id = id if id is not None else ''
 5454        '''
 5455         Unique identifier of the Resource.
 5456        '''
 5457        self.name = name if name is not None else ''
 5458        '''
 5459         Unique human-readable name of the Resource.
 5460        '''
 5461        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5462        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5463        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5464        '''
 5465         ID of the secret store containing credentials for this resource, if any.
 5466        '''
 5467        self.service_account_key = service_account_key if service_account_key is not None else ''
 5468        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5469        '''
 5470         Tags is a map of key, value pairs.
 5471        '''
 5472
 5473    def __repr__(self):
 5474        return '<sdm.GoogleGKE ' + \
 5475            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5476            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5477            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5478            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5479            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5480            'healthy: ' + repr(self.healthy) + ' ' +\
 5481            'id: ' + repr(self.id) + ' ' +\
 5482            'name: ' + repr(self.name) + ' ' +\
 5483            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5484            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5485            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5486            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5487            'tags: ' + repr(self.tags) + ' ' +\
 5488            '>'
 5489
 5490    def to_dict(self):
 5491        return {
 5492            'bind_interface': self.bind_interface,
 5493            'certificate_authority': self.certificate_authority,
 5494            'egress_filter': self.egress_filter,
 5495            'endpoint': self.endpoint,
 5496            'healthcheck_namespace': self.healthcheck_namespace,
 5497            'healthy': self.healthy,
 5498            'id': self.id,
 5499            'name': self.name,
 5500            'remote_identity_group_id': self.remote_identity_group_id,
 5501            'remote_identity_healthcheck_username':
 5502            self.remote_identity_healthcheck_username,
 5503            'secret_store_id': self.secret_store_id,
 5504            'service_account_key': self.service_account_key,
 5505            'tags': self.tags,
 5506        }
 5507
 5508    @classmethod
 5509    def from_dict(cls, d):
 5510        return cls(
 5511            bind_interface=d.get('bind_interface'),
 5512            certificate_authority=d.get('certificate_authority'),
 5513            egress_filter=d.get('egress_filter'),
 5514            endpoint=d.get('endpoint'),
 5515            healthcheck_namespace=d.get('healthcheck_namespace'),
 5516            healthy=d.get('healthy'),
 5517            id=d.get('id'),
 5518            name=d.get('name'),
 5519            remote_identity_group_id=d.get('remote_identity_group_id'),
 5520            remote_identity_healthcheck_username=d.get(
 5521                'remote_identity_healthcheck_username'),
 5522            secret_store_id=d.get('secret_store_id'),
 5523            service_account_key=d.get('service_account_key'),
 5524            tags=d.get('tags'),
 5525        )
 5526
 5527
 5528class GoogleGKEUserImpersonation:
 5529    __slots__ = [
 5530        'bind_interface',
 5531        'certificate_authority',
 5532        'egress_filter',
 5533        'endpoint',
 5534        'healthcheck_namespace',
 5535        'healthy',
 5536        'id',
 5537        'name',
 5538        'secret_store_id',
 5539        'service_account_key',
 5540        'tags',
 5541    ]
 5542
 5543    def __init__(
 5544        self,
 5545        bind_interface=None,
 5546        certificate_authority=None,
 5547        egress_filter=None,
 5548        endpoint=None,
 5549        healthcheck_namespace=None,
 5550        healthy=None,
 5551        id=None,
 5552        name=None,
 5553        secret_store_id=None,
 5554        service_account_key=None,
 5555        tags=None,
 5556    ):
 5557        self.bind_interface = bind_interface if bind_interface is not None else ''
 5558        '''
 5559         Bind interface
 5560        '''
 5561        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5562        self.egress_filter = egress_filter if egress_filter is not None else ''
 5563        '''
 5564         A filter applied to the routing logic to pin datasource to nodes.
 5565        '''
 5566        self.endpoint = endpoint if endpoint is not None else ''
 5567        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5568        '''
 5569         The path used to check the health of your connection.  Defaults to `default`.
 5570        '''
 5571        self.healthy = healthy if healthy is not None else False
 5572        '''
 5573         True if the datasource is reachable and the credentials are valid.
 5574        '''
 5575        self.id = id if id is not None else ''
 5576        '''
 5577         Unique identifier of the Resource.
 5578        '''
 5579        self.name = name if name is not None else ''
 5580        '''
 5581         Unique human-readable name of the Resource.
 5582        '''
 5583        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5584        '''
 5585         ID of the secret store containing credentials for this resource, if any.
 5586        '''
 5587        self.service_account_key = service_account_key if service_account_key is not None else ''
 5588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5589        '''
 5590         Tags is a map of key, value pairs.
 5591        '''
 5592
 5593    def __repr__(self):
 5594        return '<sdm.GoogleGKEUserImpersonation ' + \
 5595            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5596            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5597            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5598            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5599            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5600            'healthy: ' + repr(self.healthy) + ' ' +\
 5601            'id: ' + repr(self.id) + ' ' +\
 5602            'name: ' + repr(self.name) + ' ' +\
 5603            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5604            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5605            'tags: ' + repr(self.tags) + ' ' +\
 5606            '>'
 5607
 5608    def to_dict(self):
 5609        return {
 5610            'bind_interface': self.bind_interface,
 5611            'certificate_authority': self.certificate_authority,
 5612            'egress_filter': self.egress_filter,
 5613            'endpoint': self.endpoint,
 5614            'healthcheck_namespace': self.healthcheck_namespace,
 5615            'healthy': self.healthy,
 5616            'id': self.id,
 5617            'name': self.name,
 5618            'secret_store_id': self.secret_store_id,
 5619            'service_account_key': self.service_account_key,
 5620            'tags': self.tags,
 5621        }
 5622
 5623    @classmethod
 5624    def from_dict(cls, d):
 5625        return cls(
 5626            bind_interface=d.get('bind_interface'),
 5627            certificate_authority=d.get('certificate_authority'),
 5628            egress_filter=d.get('egress_filter'),
 5629            endpoint=d.get('endpoint'),
 5630            healthcheck_namespace=d.get('healthcheck_namespace'),
 5631            healthy=d.get('healthy'),
 5632            id=d.get('id'),
 5633            name=d.get('name'),
 5634            secret_store_id=d.get('secret_store_id'),
 5635            service_account_key=d.get('service_account_key'),
 5636            tags=d.get('tags'),
 5637        )
 5638
 5639
 5640class Greenplum:
 5641    __slots__ = [
 5642        'bind_interface',
 5643        'database',
 5644        'egress_filter',
 5645        'healthy',
 5646        'hostname',
 5647        'id',
 5648        'name',
 5649        'override_database',
 5650        'password',
 5651        'port',
 5652        'port_override',
 5653        'secret_store_id',
 5654        'tags',
 5655        'username',
 5656    ]
 5657
 5658    def __init__(
 5659        self,
 5660        bind_interface=None,
 5661        database=None,
 5662        egress_filter=None,
 5663        healthy=None,
 5664        hostname=None,
 5665        id=None,
 5666        name=None,
 5667        override_database=None,
 5668        password=None,
 5669        port=None,
 5670        port_override=None,
 5671        secret_store_id=None,
 5672        tags=None,
 5673        username=None,
 5674    ):
 5675        self.bind_interface = bind_interface if bind_interface is not None else ''
 5676        '''
 5677         Bind interface
 5678        '''
 5679        self.database = database if database is not None else ''
 5680        self.egress_filter = egress_filter if egress_filter is not None else ''
 5681        '''
 5682         A filter applied to the routing logic to pin datasource to nodes.
 5683        '''
 5684        self.healthy = healthy if healthy is not None else False
 5685        '''
 5686         True if the datasource is reachable and the credentials are valid.
 5687        '''
 5688        self.hostname = hostname if hostname is not None else ''
 5689        self.id = id if id is not None else ''
 5690        '''
 5691         Unique identifier of the Resource.
 5692        '''
 5693        self.name = name if name is not None else ''
 5694        '''
 5695         Unique human-readable name of the Resource.
 5696        '''
 5697        self.override_database = override_database if override_database is not None else False
 5698        self.password = password if password is not None else ''
 5699        self.port = port if port is not None else 0
 5700        self.port_override = port_override if port_override is not None else 0
 5701        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5702        '''
 5703         ID of the secret store containing credentials for this resource, if any.
 5704        '''
 5705        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5706        '''
 5707         Tags is a map of key, value pairs.
 5708        '''
 5709        self.username = username if username is not None else ''
 5710
 5711    def __repr__(self):
 5712        return '<sdm.Greenplum ' + \
 5713            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5714            'database: ' + repr(self.database) + ' ' +\
 5715            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5716            'healthy: ' + repr(self.healthy) + ' ' +\
 5717            'hostname: ' + repr(self.hostname) + ' ' +\
 5718            'id: ' + repr(self.id) + ' ' +\
 5719            'name: ' + repr(self.name) + ' ' +\
 5720            'override_database: ' + repr(self.override_database) + ' ' +\
 5721            'password: ' + repr(self.password) + ' ' +\
 5722            'port: ' + repr(self.port) + ' ' +\
 5723            'port_override: ' + repr(self.port_override) + ' ' +\
 5724            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5725            'tags: ' + repr(self.tags) + ' ' +\
 5726            'username: ' + repr(self.username) + ' ' +\
 5727            '>'
 5728
 5729    def to_dict(self):
 5730        return {
 5731            'bind_interface': self.bind_interface,
 5732            'database': self.database,
 5733            'egress_filter': self.egress_filter,
 5734            'healthy': self.healthy,
 5735            'hostname': self.hostname,
 5736            'id': self.id,
 5737            'name': self.name,
 5738            'override_database': self.override_database,
 5739            'password': self.password,
 5740            'port': self.port,
 5741            'port_override': self.port_override,
 5742            'secret_store_id': self.secret_store_id,
 5743            'tags': self.tags,
 5744            'username': self.username,
 5745        }
 5746
 5747    @classmethod
 5748    def from_dict(cls, d):
 5749        return cls(
 5750            bind_interface=d.get('bind_interface'),
 5751            database=d.get('database'),
 5752            egress_filter=d.get('egress_filter'),
 5753            healthy=d.get('healthy'),
 5754            hostname=d.get('hostname'),
 5755            id=d.get('id'),
 5756            name=d.get('name'),
 5757            override_database=d.get('override_database'),
 5758            password=d.get('password'),
 5759            port=d.get('port'),
 5760            port_override=d.get('port_override'),
 5761            secret_store_id=d.get('secret_store_id'),
 5762            tags=d.get('tags'),
 5763            username=d.get('username'),
 5764        )
 5765
 5766
 5767class HTTPAuth:
 5768    __slots__ = [
 5769        'auth_header',
 5770        'bind_interface',
 5771        'default_path',
 5772        'egress_filter',
 5773        'headers_blacklist',
 5774        'healthcheck_path',
 5775        'healthy',
 5776        'host_override',
 5777        'id',
 5778        'name',
 5779        'secret_store_id',
 5780        'subdomain',
 5781        'tags',
 5782        'url',
 5783    ]
 5784
 5785    def __init__(
 5786        self,
 5787        auth_header=None,
 5788        bind_interface=None,
 5789        default_path=None,
 5790        egress_filter=None,
 5791        headers_blacklist=None,
 5792        healthcheck_path=None,
 5793        healthy=None,
 5794        host_override=None,
 5795        id=None,
 5796        name=None,
 5797        secret_store_id=None,
 5798        subdomain=None,
 5799        tags=None,
 5800        url=None,
 5801    ):
 5802        self.auth_header = auth_header if auth_header is not None else ''
 5803        self.bind_interface = bind_interface if bind_interface is not None else ''
 5804        '''
 5805         Bind interface
 5806        '''
 5807        self.default_path = default_path if default_path is not None else ''
 5808        self.egress_filter = egress_filter if egress_filter is not None else ''
 5809        '''
 5810         A filter applied to the routing logic to pin datasource to nodes.
 5811        '''
 5812        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5813        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5814        self.healthy = healthy if healthy is not None else False
 5815        '''
 5816         True if the datasource is reachable and the credentials are valid.
 5817        '''
 5818        self.host_override = host_override if host_override is not None else ''
 5819        self.id = id if id is not None else ''
 5820        '''
 5821         Unique identifier of the Resource.
 5822        '''
 5823        self.name = name if name is not None else ''
 5824        '''
 5825         Unique human-readable name of the Resource.
 5826        '''
 5827        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5828        '''
 5829         ID of the secret store containing credentials for this resource, if any.
 5830        '''
 5831        self.subdomain = subdomain if subdomain is not None else ''
 5832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5833        '''
 5834         Tags is a map of key, value pairs.
 5835        '''
 5836        self.url = url if url is not None else ''
 5837
 5838    def __repr__(self):
 5839        return '<sdm.HTTPAuth ' + \
 5840            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5841            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5842            'default_path: ' + repr(self.default_path) + ' ' +\
 5843            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5844            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5845            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5846            'healthy: ' + repr(self.healthy) + ' ' +\
 5847            'host_override: ' + repr(self.host_override) + ' ' +\
 5848            'id: ' + repr(self.id) + ' ' +\
 5849            'name: ' + repr(self.name) + ' ' +\
 5850            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5851            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5852            'tags: ' + repr(self.tags) + ' ' +\
 5853            'url: ' + repr(self.url) + ' ' +\
 5854            '>'
 5855
 5856    def to_dict(self):
 5857        return {
 5858            'auth_header': self.auth_header,
 5859            'bind_interface': self.bind_interface,
 5860            'default_path': self.default_path,
 5861            'egress_filter': self.egress_filter,
 5862            'headers_blacklist': self.headers_blacklist,
 5863            'healthcheck_path': self.healthcheck_path,
 5864            'healthy': self.healthy,
 5865            'host_override': self.host_override,
 5866            'id': self.id,
 5867            'name': self.name,
 5868            'secret_store_id': self.secret_store_id,
 5869            'subdomain': self.subdomain,
 5870            'tags': self.tags,
 5871            'url': self.url,
 5872        }
 5873
 5874    @classmethod
 5875    def from_dict(cls, d):
 5876        return cls(
 5877            auth_header=d.get('auth_header'),
 5878            bind_interface=d.get('bind_interface'),
 5879            default_path=d.get('default_path'),
 5880            egress_filter=d.get('egress_filter'),
 5881            headers_blacklist=d.get('headers_blacklist'),
 5882            healthcheck_path=d.get('healthcheck_path'),
 5883            healthy=d.get('healthy'),
 5884            host_override=d.get('host_override'),
 5885            id=d.get('id'),
 5886            name=d.get('name'),
 5887            secret_store_id=d.get('secret_store_id'),
 5888            subdomain=d.get('subdomain'),
 5889            tags=d.get('tags'),
 5890            url=d.get('url'),
 5891        )
 5892
 5893
 5894class HTTPBasicAuth:
 5895    __slots__ = [
 5896        'bind_interface',
 5897        'default_path',
 5898        'egress_filter',
 5899        'headers_blacklist',
 5900        'healthcheck_path',
 5901        'healthy',
 5902        'host_override',
 5903        'id',
 5904        'name',
 5905        'password',
 5906        'secret_store_id',
 5907        'subdomain',
 5908        'tags',
 5909        'url',
 5910        'username',
 5911    ]
 5912
 5913    def __init__(
 5914        self,
 5915        bind_interface=None,
 5916        default_path=None,
 5917        egress_filter=None,
 5918        headers_blacklist=None,
 5919        healthcheck_path=None,
 5920        healthy=None,
 5921        host_override=None,
 5922        id=None,
 5923        name=None,
 5924        password=None,
 5925        secret_store_id=None,
 5926        subdomain=None,
 5927        tags=None,
 5928        url=None,
 5929        username=None,
 5930    ):
 5931        self.bind_interface = bind_interface if bind_interface is not None else ''
 5932        '''
 5933         Bind interface
 5934        '''
 5935        self.default_path = default_path if default_path is not None else ''
 5936        self.egress_filter = egress_filter if egress_filter is not None else ''
 5937        '''
 5938         A filter applied to the routing logic to pin datasource to nodes.
 5939        '''
 5940        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5941        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5942        self.healthy = healthy if healthy is not None else False
 5943        '''
 5944         True if the datasource is reachable and the credentials are valid.
 5945        '''
 5946        self.host_override = host_override if host_override is not None else ''
 5947        self.id = id if id is not None else ''
 5948        '''
 5949         Unique identifier of the Resource.
 5950        '''
 5951        self.name = name if name is not None else ''
 5952        '''
 5953         Unique human-readable name of the Resource.
 5954        '''
 5955        self.password = password if password is not None else ''
 5956        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5957        '''
 5958         ID of the secret store containing credentials for this resource, if any.
 5959        '''
 5960        self.subdomain = subdomain if subdomain is not None else ''
 5961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5962        '''
 5963         Tags is a map of key, value pairs.
 5964        '''
 5965        self.url = url if url is not None else ''
 5966        self.username = username if username is not None else ''
 5967
 5968    def __repr__(self):
 5969        return '<sdm.HTTPBasicAuth ' + \
 5970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5971            'default_path: ' + repr(self.default_path) + ' ' +\
 5972            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5973            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5974            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5975            'healthy: ' + repr(self.healthy) + ' ' +\
 5976            'host_override: ' + repr(self.host_override) + ' ' +\
 5977            'id: ' + repr(self.id) + ' ' +\
 5978            'name: ' + repr(self.name) + ' ' +\
 5979            'password: ' + repr(self.password) + ' ' +\
 5980            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5981            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5982            'tags: ' + repr(self.tags) + ' ' +\
 5983            'url: ' + repr(self.url) + ' ' +\
 5984            'username: ' + repr(self.username) + ' ' +\
 5985            '>'
 5986
 5987    def to_dict(self):
 5988        return {
 5989            'bind_interface': self.bind_interface,
 5990            'default_path': self.default_path,
 5991            'egress_filter': self.egress_filter,
 5992            'headers_blacklist': self.headers_blacklist,
 5993            'healthcheck_path': self.healthcheck_path,
 5994            'healthy': self.healthy,
 5995            'host_override': self.host_override,
 5996            'id': self.id,
 5997            'name': self.name,
 5998            'password': self.password,
 5999            'secret_store_id': self.secret_store_id,
 6000            'subdomain': self.subdomain,
 6001            'tags': self.tags,
 6002            'url': self.url,
 6003            'username': self.username,
 6004        }
 6005
 6006    @classmethod
 6007    def from_dict(cls, d):
 6008        return cls(
 6009            bind_interface=d.get('bind_interface'),
 6010            default_path=d.get('default_path'),
 6011            egress_filter=d.get('egress_filter'),
 6012            headers_blacklist=d.get('headers_blacklist'),
 6013            healthcheck_path=d.get('healthcheck_path'),
 6014            healthy=d.get('healthy'),
 6015            host_override=d.get('host_override'),
 6016            id=d.get('id'),
 6017            name=d.get('name'),
 6018            password=d.get('password'),
 6019            secret_store_id=d.get('secret_store_id'),
 6020            subdomain=d.get('subdomain'),
 6021            tags=d.get('tags'),
 6022            url=d.get('url'),
 6023            username=d.get('username'),
 6024        )
 6025
 6026
 6027class HTTPNoAuth:
 6028    __slots__ = [
 6029        'bind_interface',
 6030        'default_path',
 6031        'egress_filter',
 6032        'headers_blacklist',
 6033        'healthcheck_path',
 6034        'healthy',
 6035        'host_override',
 6036        'id',
 6037        'name',
 6038        'secret_store_id',
 6039        'subdomain',
 6040        'tags',
 6041        'url',
 6042    ]
 6043
 6044    def __init__(
 6045        self,
 6046        bind_interface=None,
 6047        default_path=None,
 6048        egress_filter=None,
 6049        headers_blacklist=None,
 6050        healthcheck_path=None,
 6051        healthy=None,
 6052        host_override=None,
 6053        id=None,
 6054        name=None,
 6055        secret_store_id=None,
 6056        subdomain=None,
 6057        tags=None,
 6058        url=None,
 6059    ):
 6060        self.bind_interface = bind_interface if bind_interface is not None else ''
 6061        '''
 6062         Bind interface
 6063        '''
 6064        self.default_path = default_path if default_path is not None else ''
 6065        self.egress_filter = egress_filter if egress_filter is not None else ''
 6066        '''
 6067         A filter applied to the routing logic to pin datasource to nodes.
 6068        '''
 6069        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6070        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6071        self.healthy = healthy if healthy is not None else False
 6072        '''
 6073         True if the datasource is reachable and the credentials are valid.
 6074        '''
 6075        self.host_override = host_override if host_override is not None else ''
 6076        self.id = id if id is not None else ''
 6077        '''
 6078         Unique identifier of the Resource.
 6079        '''
 6080        self.name = name if name is not None else ''
 6081        '''
 6082         Unique human-readable name of the Resource.
 6083        '''
 6084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6085        '''
 6086         ID of the secret store containing credentials for this resource, if any.
 6087        '''
 6088        self.subdomain = subdomain if subdomain is not None else ''
 6089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6090        '''
 6091         Tags is a map of key, value pairs.
 6092        '''
 6093        self.url = url if url is not None else ''
 6094
 6095    def __repr__(self):
 6096        return '<sdm.HTTPNoAuth ' + \
 6097            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6098            'default_path: ' + repr(self.default_path) + ' ' +\
 6099            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6100            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6101            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6102            'healthy: ' + repr(self.healthy) + ' ' +\
 6103            'host_override: ' + repr(self.host_override) + ' ' +\
 6104            'id: ' + repr(self.id) + ' ' +\
 6105            'name: ' + repr(self.name) + ' ' +\
 6106            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6107            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6108            'tags: ' + repr(self.tags) + ' ' +\
 6109            'url: ' + repr(self.url) + ' ' +\
 6110            '>'
 6111
 6112    def to_dict(self):
 6113        return {
 6114            'bind_interface': self.bind_interface,
 6115            'default_path': self.default_path,
 6116            'egress_filter': self.egress_filter,
 6117            'headers_blacklist': self.headers_blacklist,
 6118            'healthcheck_path': self.healthcheck_path,
 6119            'healthy': self.healthy,
 6120            'host_override': self.host_override,
 6121            'id': self.id,
 6122            'name': self.name,
 6123            'secret_store_id': self.secret_store_id,
 6124            'subdomain': self.subdomain,
 6125            'tags': self.tags,
 6126            'url': self.url,
 6127        }
 6128
 6129    @classmethod
 6130    def from_dict(cls, d):
 6131        return cls(
 6132            bind_interface=d.get('bind_interface'),
 6133            default_path=d.get('default_path'),
 6134            egress_filter=d.get('egress_filter'),
 6135            headers_blacklist=d.get('headers_blacklist'),
 6136            healthcheck_path=d.get('healthcheck_path'),
 6137            healthy=d.get('healthy'),
 6138            host_override=d.get('host_override'),
 6139            id=d.get('id'),
 6140            name=d.get('name'),
 6141            secret_store_id=d.get('secret_store_id'),
 6142            subdomain=d.get('subdomain'),
 6143            tags=d.get('tags'),
 6144            url=d.get('url'),
 6145        )
 6146
 6147
 6148class Kubernetes:
 6149    __slots__ = [
 6150        'bind_interface',
 6151        'certificate_authority',
 6152        'client_certificate',
 6153        'client_key',
 6154        'egress_filter',
 6155        'healthcheck_namespace',
 6156        'healthy',
 6157        'hostname',
 6158        'id',
 6159        'name',
 6160        'port',
 6161        'port_override',
 6162        'remote_identity_group_id',
 6163        'remote_identity_healthcheck_username',
 6164        'secret_store_id',
 6165        'tags',
 6166    ]
 6167
 6168    def __init__(
 6169        self,
 6170        bind_interface=None,
 6171        certificate_authority=None,
 6172        client_certificate=None,
 6173        client_key=None,
 6174        egress_filter=None,
 6175        healthcheck_namespace=None,
 6176        healthy=None,
 6177        hostname=None,
 6178        id=None,
 6179        name=None,
 6180        port=None,
 6181        port_override=None,
 6182        remote_identity_group_id=None,
 6183        remote_identity_healthcheck_username=None,
 6184        secret_store_id=None,
 6185        tags=None,
 6186    ):
 6187        self.bind_interface = bind_interface if bind_interface is not None else ''
 6188        '''
 6189         Bind interface
 6190        '''
 6191        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6192        self.client_certificate = client_certificate if client_certificate is not None else ''
 6193        self.client_key = client_key if client_key is not None else ''
 6194        self.egress_filter = egress_filter if egress_filter is not None else ''
 6195        '''
 6196         A filter applied to the routing logic to pin datasource to nodes.
 6197        '''
 6198        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6199        '''
 6200         The path used to check the health of your connection.  Defaults to `default`.
 6201        '''
 6202        self.healthy = healthy if healthy is not None else False
 6203        '''
 6204         True if the datasource is reachable and the credentials are valid.
 6205        '''
 6206        self.hostname = hostname if hostname is not None else ''
 6207        self.id = id if id is not None else ''
 6208        '''
 6209         Unique identifier of the Resource.
 6210        '''
 6211        self.name = name if name is not None else ''
 6212        '''
 6213         Unique human-readable name of the Resource.
 6214        '''
 6215        self.port = port if port is not None else 0
 6216        self.port_override = port_override if port_override is not None else 0
 6217        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6218        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6219        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6220        '''
 6221         ID of the secret store containing credentials for this resource, if any.
 6222        '''
 6223        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6224        '''
 6225         Tags is a map of key, value pairs.
 6226        '''
 6227
 6228    def __repr__(self):
 6229        return '<sdm.Kubernetes ' + \
 6230            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6231            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6232            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6233            'client_key: ' + repr(self.client_key) + ' ' +\
 6234            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6235            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6236            'healthy: ' + repr(self.healthy) + ' ' +\
 6237            'hostname: ' + repr(self.hostname) + ' ' +\
 6238            'id: ' + repr(self.id) + ' ' +\
 6239            'name: ' + repr(self.name) + ' ' +\
 6240            'port: ' + repr(self.port) + ' ' +\
 6241            'port_override: ' + repr(self.port_override) + ' ' +\
 6242            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6243            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6244            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6245            'tags: ' + repr(self.tags) + ' ' +\
 6246            '>'
 6247
 6248    def to_dict(self):
 6249        return {
 6250            'bind_interface': self.bind_interface,
 6251            'certificate_authority': self.certificate_authority,
 6252            'client_certificate': self.client_certificate,
 6253            'client_key': self.client_key,
 6254            'egress_filter': self.egress_filter,
 6255            'healthcheck_namespace': self.healthcheck_namespace,
 6256            'healthy': self.healthy,
 6257            'hostname': self.hostname,
 6258            'id': self.id,
 6259            'name': self.name,
 6260            'port': self.port,
 6261            'port_override': self.port_override,
 6262            'remote_identity_group_id': self.remote_identity_group_id,
 6263            'remote_identity_healthcheck_username':
 6264            self.remote_identity_healthcheck_username,
 6265            'secret_store_id': self.secret_store_id,
 6266            'tags': self.tags,
 6267        }
 6268
 6269    @classmethod
 6270    def from_dict(cls, d):
 6271        return cls(
 6272            bind_interface=d.get('bind_interface'),
 6273            certificate_authority=d.get('certificate_authority'),
 6274            client_certificate=d.get('client_certificate'),
 6275            client_key=d.get('client_key'),
 6276            egress_filter=d.get('egress_filter'),
 6277            healthcheck_namespace=d.get('healthcheck_namespace'),
 6278            healthy=d.get('healthy'),
 6279            hostname=d.get('hostname'),
 6280            id=d.get('id'),
 6281            name=d.get('name'),
 6282            port=d.get('port'),
 6283            port_override=d.get('port_override'),
 6284            remote_identity_group_id=d.get('remote_identity_group_id'),
 6285            remote_identity_healthcheck_username=d.get(
 6286                'remote_identity_healthcheck_username'),
 6287            secret_store_id=d.get('secret_store_id'),
 6288            tags=d.get('tags'),
 6289        )
 6290
 6291
 6292class KubernetesBasicAuth:
 6293    __slots__ = [
 6294        'bind_interface',
 6295        'egress_filter',
 6296        'healthcheck_namespace',
 6297        'healthy',
 6298        'hostname',
 6299        'id',
 6300        'name',
 6301        'password',
 6302        'port',
 6303        'port_override',
 6304        'secret_store_id',
 6305        'tags',
 6306        'username',
 6307    ]
 6308
 6309    def __init__(
 6310        self,
 6311        bind_interface=None,
 6312        egress_filter=None,
 6313        healthcheck_namespace=None,
 6314        healthy=None,
 6315        hostname=None,
 6316        id=None,
 6317        name=None,
 6318        password=None,
 6319        port=None,
 6320        port_override=None,
 6321        secret_store_id=None,
 6322        tags=None,
 6323        username=None,
 6324    ):
 6325        self.bind_interface = bind_interface if bind_interface is not None else ''
 6326        '''
 6327         Bind interface
 6328        '''
 6329        self.egress_filter = egress_filter if egress_filter is not None else ''
 6330        '''
 6331         A filter applied to the routing logic to pin datasource to nodes.
 6332        '''
 6333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6334        '''
 6335         The path used to check the health of your connection.  Defaults to `default`.
 6336        '''
 6337        self.healthy = healthy if healthy is not None else False
 6338        '''
 6339         True if the datasource is reachable and the credentials are valid.
 6340        '''
 6341        self.hostname = hostname if hostname is not None else ''
 6342        self.id = id if id is not None else ''
 6343        '''
 6344         Unique identifier of the Resource.
 6345        '''
 6346        self.name = name if name is not None else ''
 6347        '''
 6348         Unique human-readable name of the Resource.
 6349        '''
 6350        self.password = password if password is not None else ''
 6351        self.port = port if port is not None else 0
 6352        self.port_override = port_override if port_override is not None else 0
 6353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6354        '''
 6355         ID of the secret store containing credentials for this resource, if any.
 6356        '''
 6357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6358        '''
 6359         Tags is a map of key, value pairs.
 6360        '''
 6361        self.username = username if username is not None else ''
 6362
 6363    def __repr__(self):
 6364        return '<sdm.KubernetesBasicAuth ' + \
 6365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6368            'healthy: ' + repr(self.healthy) + ' ' +\
 6369            'hostname: ' + repr(self.hostname) + ' ' +\
 6370            'id: ' + repr(self.id) + ' ' +\
 6371            'name: ' + repr(self.name) + ' ' +\
 6372            'password: ' + repr(self.password) + ' ' +\
 6373            'port: ' + repr(self.port) + ' ' +\
 6374            'port_override: ' + repr(self.port_override) + ' ' +\
 6375            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6376            'tags: ' + repr(self.tags) + ' ' +\
 6377            'username: ' + repr(self.username) + ' ' +\
 6378            '>'
 6379
 6380    def to_dict(self):
 6381        return {
 6382            'bind_interface': self.bind_interface,
 6383            'egress_filter': self.egress_filter,
 6384            'healthcheck_namespace': self.healthcheck_namespace,
 6385            'healthy': self.healthy,
 6386            'hostname': self.hostname,
 6387            'id': self.id,
 6388            'name': self.name,
 6389            'password': self.password,
 6390            'port': self.port,
 6391            'port_override': self.port_override,
 6392            'secret_store_id': self.secret_store_id,
 6393            'tags': self.tags,
 6394            'username': self.username,
 6395        }
 6396
 6397    @classmethod
 6398    def from_dict(cls, d):
 6399        return cls(
 6400            bind_interface=d.get('bind_interface'),
 6401            egress_filter=d.get('egress_filter'),
 6402            healthcheck_namespace=d.get('healthcheck_namespace'),
 6403            healthy=d.get('healthy'),
 6404            hostname=d.get('hostname'),
 6405            id=d.get('id'),
 6406            name=d.get('name'),
 6407            password=d.get('password'),
 6408            port=d.get('port'),
 6409            port_override=d.get('port_override'),
 6410            secret_store_id=d.get('secret_store_id'),
 6411            tags=d.get('tags'),
 6412            username=d.get('username'),
 6413        )
 6414
 6415
 6416class KubernetesServiceAccount:
 6417    __slots__ = [
 6418        'bind_interface',
 6419        'egress_filter',
 6420        'healthcheck_namespace',
 6421        'healthy',
 6422        'hostname',
 6423        'id',
 6424        'name',
 6425        'port',
 6426        'port_override',
 6427        'remote_identity_group_id',
 6428        'remote_identity_healthcheck_username',
 6429        'secret_store_id',
 6430        'tags',
 6431        'token',
 6432    ]
 6433
 6434    def __init__(
 6435        self,
 6436        bind_interface=None,
 6437        egress_filter=None,
 6438        healthcheck_namespace=None,
 6439        healthy=None,
 6440        hostname=None,
 6441        id=None,
 6442        name=None,
 6443        port=None,
 6444        port_override=None,
 6445        remote_identity_group_id=None,
 6446        remote_identity_healthcheck_username=None,
 6447        secret_store_id=None,
 6448        tags=None,
 6449        token=None,
 6450    ):
 6451        self.bind_interface = bind_interface if bind_interface is not None else ''
 6452        '''
 6453         Bind interface
 6454        '''
 6455        self.egress_filter = egress_filter if egress_filter is not None else ''
 6456        '''
 6457         A filter applied to the routing logic to pin datasource to nodes.
 6458        '''
 6459        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6460        '''
 6461         The path used to check the health of your connection.  Defaults to `default`.
 6462        '''
 6463        self.healthy = healthy if healthy is not None else False
 6464        '''
 6465         True if the datasource is reachable and the credentials are valid.
 6466        '''
 6467        self.hostname = hostname if hostname is not None else ''
 6468        self.id = id if id is not None else ''
 6469        '''
 6470         Unique identifier of the Resource.
 6471        '''
 6472        self.name = name if name is not None else ''
 6473        '''
 6474         Unique human-readable name of the Resource.
 6475        '''
 6476        self.port = port if port is not None else 0
 6477        self.port_override = port_override if port_override is not None else 0
 6478        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6479        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6481        '''
 6482         ID of the secret store containing credentials for this resource, if any.
 6483        '''
 6484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6485        '''
 6486         Tags is a map of key, value pairs.
 6487        '''
 6488        self.token = token if token is not None else ''
 6489
 6490    def __repr__(self):
 6491        return '<sdm.KubernetesServiceAccount ' + \
 6492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6495            'healthy: ' + repr(self.healthy) + ' ' +\
 6496            'hostname: ' + repr(self.hostname) + ' ' +\
 6497            'id: ' + repr(self.id) + ' ' +\
 6498            'name: ' + repr(self.name) + ' ' +\
 6499            'port: ' + repr(self.port) + ' ' +\
 6500            'port_override: ' + repr(self.port_override) + ' ' +\
 6501            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6502            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6503            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6504            'tags: ' + repr(self.tags) + ' ' +\
 6505            'token: ' + repr(self.token) + ' ' +\
 6506            '>'
 6507
 6508    def to_dict(self):
 6509        return {
 6510            'bind_interface': self.bind_interface,
 6511            'egress_filter': self.egress_filter,
 6512            'healthcheck_namespace': self.healthcheck_namespace,
 6513            'healthy': self.healthy,
 6514            'hostname': self.hostname,
 6515            'id': self.id,
 6516            'name': self.name,
 6517            'port': self.port,
 6518            'port_override': self.port_override,
 6519            'remote_identity_group_id': self.remote_identity_group_id,
 6520            'remote_identity_healthcheck_username':
 6521            self.remote_identity_healthcheck_username,
 6522            'secret_store_id': self.secret_store_id,
 6523            'tags': self.tags,
 6524            'token': self.token,
 6525        }
 6526
 6527    @classmethod
 6528    def from_dict(cls, d):
 6529        return cls(
 6530            bind_interface=d.get('bind_interface'),
 6531            egress_filter=d.get('egress_filter'),
 6532            healthcheck_namespace=d.get('healthcheck_namespace'),
 6533            healthy=d.get('healthy'),
 6534            hostname=d.get('hostname'),
 6535            id=d.get('id'),
 6536            name=d.get('name'),
 6537            port=d.get('port'),
 6538            port_override=d.get('port_override'),
 6539            remote_identity_group_id=d.get('remote_identity_group_id'),
 6540            remote_identity_healthcheck_username=d.get(
 6541                'remote_identity_healthcheck_username'),
 6542            secret_store_id=d.get('secret_store_id'),
 6543            tags=d.get('tags'),
 6544            token=d.get('token'),
 6545        )
 6546
 6547
 6548class KubernetesServiceAccountUserImpersonation:
 6549    __slots__ = [
 6550        'bind_interface',
 6551        'egress_filter',
 6552        'healthcheck_namespace',
 6553        'healthy',
 6554        'hostname',
 6555        'id',
 6556        'name',
 6557        'port',
 6558        'port_override',
 6559        'secret_store_id',
 6560        'tags',
 6561        'token',
 6562    ]
 6563
 6564    def __init__(
 6565        self,
 6566        bind_interface=None,
 6567        egress_filter=None,
 6568        healthcheck_namespace=None,
 6569        healthy=None,
 6570        hostname=None,
 6571        id=None,
 6572        name=None,
 6573        port=None,
 6574        port_override=None,
 6575        secret_store_id=None,
 6576        tags=None,
 6577        token=None,
 6578    ):
 6579        self.bind_interface = bind_interface if bind_interface is not None else ''
 6580        '''
 6581         Bind interface
 6582        '''
 6583        self.egress_filter = egress_filter if egress_filter is not None else ''
 6584        '''
 6585         A filter applied to the routing logic to pin datasource to nodes.
 6586        '''
 6587        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6588        '''
 6589         The path used to check the health of your connection.  Defaults to `default`.
 6590        '''
 6591        self.healthy = healthy if healthy is not None else False
 6592        '''
 6593         True if the datasource is reachable and the credentials are valid.
 6594        '''
 6595        self.hostname = hostname if hostname is not None else ''
 6596        self.id = id if id is not None else ''
 6597        '''
 6598         Unique identifier of the Resource.
 6599        '''
 6600        self.name = name if name is not None else ''
 6601        '''
 6602         Unique human-readable name of the Resource.
 6603        '''
 6604        self.port = port if port is not None else 0
 6605        self.port_override = port_override if port_override is not None else 0
 6606        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6607        '''
 6608         ID of the secret store containing credentials for this resource, if any.
 6609        '''
 6610        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6611        '''
 6612         Tags is a map of key, value pairs.
 6613        '''
 6614        self.token = token if token is not None else ''
 6615
 6616    def __repr__(self):
 6617        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6618            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6621            'healthy: ' + repr(self.healthy) + ' ' +\
 6622            'hostname: ' + repr(self.hostname) + ' ' +\
 6623            'id: ' + repr(self.id) + ' ' +\
 6624            'name: ' + repr(self.name) + ' ' +\
 6625            'port: ' + repr(self.port) + ' ' +\
 6626            'port_override: ' + repr(self.port_override) + ' ' +\
 6627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6628            'tags: ' + repr(self.tags) + ' ' +\
 6629            'token: ' + repr(self.token) + ' ' +\
 6630            '>'
 6631
 6632    def to_dict(self):
 6633        return {
 6634            'bind_interface': self.bind_interface,
 6635            'egress_filter': self.egress_filter,
 6636            'healthcheck_namespace': self.healthcheck_namespace,
 6637            'healthy': self.healthy,
 6638            'hostname': self.hostname,
 6639            'id': self.id,
 6640            'name': self.name,
 6641            'port': self.port,
 6642            'port_override': self.port_override,
 6643            'secret_store_id': self.secret_store_id,
 6644            'tags': self.tags,
 6645            'token': self.token,
 6646        }
 6647
 6648    @classmethod
 6649    def from_dict(cls, d):
 6650        return cls(
 6651            bind_interface=d.get('bind_interface'),
 6652            egress_filter=d.get('egress_filter'),
 6653            healthcheck_namespace=d.get('healthcheck_namespace'),
 6654            healthy=d.get('healthy'),
 6655            hostname=d.get('hostname'),
 6656            id=d.get('id'),
 6657            name=d.get('name'),
 6658            port=d.get('port'),
 6659            port_override=d.get('port_override'),
 6660            secret_store_id=d.get('secret_store_id'),
 6661            tags=d.get('tags'),
 6662            token=d.get('token'),
 6663        )
 6664
 6665
 6666class KubernetesUserImpersonation:
 6667    __slots__ = [
 6668        'bind_interface',
 6669        'certificate_authority',
 6670        'client_certificate',
 6671        'client_key',
 6672        'egress_filter',
 6673        'healthcheck_namespace',
 6674        'healthy',
 6675        'hostname',
 6676        'id',
 6677        'name',
 6678        'port',
 6679        'port_override',
 6680        'secret_store_id',
 6681        'tags',
 6682    ]
 6683
 6684    def __init__(
 6685        self,
 6686        bind_interface=None,
 6687        certificate_authority=None,
 6688        client_certificate=None,
 6689        client_key=None,
 6690        egress_filter=None,
 6691        healthcheck_namespace=None,
 6692        healthy=None,
 6693        hostname=None,
 6694        id=None,
 6695        name=None,
 6696        port=None,
 6697        port_override=None,
 6698        secret_store_id=None,
 6699        tags=None,
 6700    ):
 6701        self.bind_interface = bind_interface if bind_interface is not None else ''
 6702        '''
 6703         Bind interface
 6704        '''
 6705        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6706        self.client_certificate = client_certificate if client_certificate is not None else ''
 6707        self.client_key = client_key if client_key is not None else ''
 6708        self.egress_filter = egress_filter if egress_filter is not None else ''
 6709        '''
 6710         A filter applied to the routing logic to pin datasource to nodes.
 6711        '''
 6712        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6713        '''
 6714         The path used to check the health of your connection.  Defaults to `default`.
 6715        '''
 6716        self.healthy = healthy if healthy is not None else False
 6717        '''
 6718         True if the datasource is reachable and the credentials are valid.
 6719        '''
 6720        self.hostname = hostname if hostname is not None else ''
 6721        self.id = id if id is not None else ''
 6722        '''
 6723         Unique identifier of the Resource.
 6724        '''
 6725        self.name = name if name is not None else ''
 6726        '''
 6727         Unique human-readable name of the Resource.
 6728        '''
 6729        self.port = port if port is not None else 0
 6730        self.port_override = port_override if port_override is not None else 0
 6731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6732        '''
 6733         ID of the secret store containing credentials for this resource, if any.
 6734        '''
 6735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6736        '''
 6737         Tags is a map of key, value pairs.
 6738        '''
 6739
 6740    def __repr__(self):
 6741        return '<sdm.KubernetesUserImpersonation ' + \
 6742            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6743            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6744            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6745            'client_key: ' + repr(self.client_key) + ' ' +\
 6746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6747            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6748            'healthy: ' + repr(self.healthy) + ' ' +\
 6749            'hostname: ' + repr(self.hostname) + ' ' +\
 6750            'id: ' + repr(self.id) + ' ' +\
 6751            'name: ' + repr(self.name) + ' ' +\
 6752            'port: ' + repr(self.port) + ' ' +\
 6753            'port_override: ' + repr(self.port_override) + ' ' +\
 6754            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6755            'tags: ' + repr(self.tags) + ' ' +\
 6756            '>'
 6757
 6758    def to_dict(self):
 6759        return {
 6760            'bind_interface': self.bind_interface,
 6761            'certificate_authority': self.certificate_authority,
 6762            'client_certificate': self.client_certificate,
 6763            'client_key': self.client_key,
 6764            'egress_filter': self.egress_filter,
 6765            'healthcheck_namespace': self.healthcheck_namespace,
 6766            'healthy': self.healthy,
 6767            'hostname': self.hostname,
 6768            'id': self.id,
 6769            'name': self.name,
 6770            'port': self.port,
 6771            'port_override': self.port_override,
 6772            'secret_store_id': self.secret_store_id,
 6773            'tags': self.tags,
 6774        }
 6775
 6776    @classmethod
 6777    def from_dict(cls, d):
 6778        return cls(
 6779            bind_interface=d.get('bind_interface'),
 6780            certificate_authority=d.get('certificate_authority'),
 6781            client_certificate=d.get('client_certificate'),
 6782            client_key=d.get('client_key'),
 6783            egress_filter=d.get('egress_filter'),
 6784            healthcheck_namespace=d.get('healthcheck_namespace'),
 6785            healthy=d.get('healthy'),
 6786            hostname=d.get('hostname'),
 6787            id=d.get('id'),
 6788            name=d.get('name'),
 6789            port=d.get('port'),
 6790            port_override=d.get('port_override'),
 6791            secret_store_id=d.get('secret_store_id'),
 6792            tags=d.get('tags'),
 6793        )
 6794
 6795
 6796class MTLSMysql:
 6797    '''
 6798    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6799    without a major version bump.
 6800    '''
 6801    __slots__ = [
 6802        'bind_interface',
 6803        'certificate_authority',
 6804        'client_certificate',
 6805        'client_key',
 6806        'database',
 6807        'egress_filter',
 6808        'healthy',
 6809        'hostname',
 6810        'id',
 6811        'name',
 6812        'password',
 6813        'port',
 6814        'port_override',
 6815        'secret_store_id',
 6816        'server_name',
 6817        'tags',
 6818        'username',
 6819    ]
 6820
 6821    def __init__(
 6822        self,
 6823        bind_interface=None,
 6824        certificate_authority=None,
 6825        client_certificate=None,
 6826        client_key=None,
 6827        database=None,
 6828        egress_filter=None,
 6829        healthy=None,
 6830        hostname=None,
 6831        id=None,
 6832        name=None,
 6833        password=None,
 6834        port=None,
 6835        port_override=None,
 6836        secret_store_id=None,
 6837        server_name=None,
 6838        tags=None,
 6839        username=None,
 6840    ):
 6841        self.bind_interface = bind_interface if bind_interface is not None else ''
 6842        '''
 6843         Bind interface
 6844        '''
 6845        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6846        self.client_certificate = client_certificate if client_certificate is not None else ''
 6847        self.client_key = client_key if client_key is not None else ''
 6848        self.database = database if database is not None else ''
 6849        self.egress_filter = egress_filter if egress_filter is not None else ''
 6850        '''
 6851         A filter applied to the routing logic to pin datasource to nodes.
 6852        '''
 6853        self.healthy = healthy if healthy is not None else False
 6854        '''
 6855         True if the datasource is reachable and the credentials are valid.
 6856        '''
 6857        self.hostname = hostname if hostname is not None else ''
 6858        self.id = id if id is not None else ''
 6859        '''
 6860         Unique identifier of the Resource.
 6861        '''
 6862        self.name = name if name is not None else ''
 6863        '''
 6864         Unique human-readable name of the Resource.
 6865        '''
 6866        self.password = password if password is not None else ''
 6867        self.port = port if port is not None else 0
 6868        self.port_override = port_override if port_override is not None else 0
 6869        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6870        '''
 6871         ID of the secret store containing credentials for this resource, if any.
 6872        '''
 6873        self.server_name = server_name if server_name is not None else ''
 6874        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6875        '''
 6876         Tags is a map of key, value pairs.
 6877        '''
 6878        self.username = username if username is not None else ''
 6879
 6880    def __repr__(self):
 6881        return '<sdm.MTLSMysql ' + \
 6882            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6883            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6884            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6885            'client_key: ' + repr(self.client_key) + ' ' +\
 6886            'database: ' + repr(self.database) + ' ' +\
 6887            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6888            'healthy: ' + repr(self.healthy) + ' ' +\
 6889            'hostname: ' + repr(self.hostname) + ' ' +\
 6890            'id: ' + repr(self.id) + ' ' +\
 6891            'name: ' + repr(self.name) + ' ' +\
 6892            'password: ' + repr(self.password) + ' ' +\
 6893            'port: ' + repr(self.port) + ' ' +\
 6894            'port_override: ' + repr(self.port_override) + ' ' +\
 6895            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6896            'server_name: ' + repr(self.server_name) + ' ' +\
 6897            'tags: ' + repr(self.tags) + ' ' +\
 6898            'username: ' + repr(self.username) + ' ' +\
 6899            '>'
 6900
 6901    def to_dict(self):
 6902        return {
 6903            'bind_interface': self.bind_interface,
 6904            'certificate_authority': self.certificate_authority,
 6905            'client_certificate': self.client_certificate,
 6906            'client_key': self.client_key,
 6907            'database': self.database,
 6908            'egress_filter': self.egress_filter,
 6909            'healthy': self.healthy,
 6910            'hostname': self.hostname,
 6911            'id': self.id,
 6912            'name': self.name,
 6913            'password': self.password,
 6914            'port': self.port,
 6915            'port_override': self.port_override,
 6916            'secret_store_id': self.secret_store_id,
 6917            'server_name': self.server_name,
 6918            'tags': self.tags,
 6919            'username': self.username,
 6920        }
 6921
 6922    @classmethod
 6923    def from_dict(cls, d):
 6924        return cls(
 6925            bind_interface=d.get('bind_interface'),
 6926            certificate_authority=d.get('certificate_authority'),
 6927            client_certificate=d.get('client_certificate'),
 6928            client_key=d.get('client_key'),
 6929            database=d.get('database'),
 6930            egress_filter=d.get('egress_filter'),
 6931            healthy=d.get('healthy'),
 6932            hostname=d.get('hostname'),
 6933            id=d.get('id'),
 6934            name=d.get('name'),
 6935            password=d.get('password'),
 6936            port=d.get('port'),
 6937            port_override=d.get('port_override'),
 6938            secret_store_id=d.get('secret_store_id'),
 6939            server_name=d.get('server_name'),
 6940            tags=d.get('tags'),
 6941            username=d.get('username'),
 6942        )
 6943
 6944
 6945class MTLSPostgres:
 6946    __slots__ = [
 6947        'bind_interface',
 6948        'certificate_authority',
 6949        'client_certificate',
 6950        'client_key',
 6951        'database',
 6952        'egress_filter',
 6953        'healthy',
 6954        'hostname',
 6955        'id',
 6956        'name',
 6957        'override_database',
 6958        'password',
 6959        'port',
 6960        'port_override',
 6961        'secret_store_id',
 6962        'server_name',
 6963        'tags',
 6964        'username',
 6965    ]
 6966
 6967    def __init__(
 6968        self,
 6969        bind_interface=None,
 6970        certificate_authority=None,
 6971        client_certificate=None,
 6972        client_key=None,
 6973        database=None,
 6974        egress_filter=None,
 6975        healthy=None,
 6976        hostname=None,
 6977        id=None,
 6978        name=None,
 6979        override_database=None,
 6980        password=None,
 6981        port=None,
 6982        port_override=None,
 6983        secret_store_id=None,
 6984        server_name=None,
 6985        tags=None,
 6986        username=None,
 6987    ):
 6988        self.bind_interface = bind_interface if bind_interface is not None else ''
 6989        '''
 6990         Bind interface
 6991        '''
 6992        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6993        self.client_certificate = client_certificate if client_certificate is not None else ''
 6994        self.client_key = client_key if client_key is not None else ''
 6995        self.database = database if database is not None else ''
 6996        self.egress_filter = egress_filter if egress_filter is not None else ''
 6997        '''
 6998         A filter applied to the routing logic to pin datasource to nodes.
 6999        '''
 7000        self.healthy = healthy if healthy is not None else False
 7001        '''
 7002         True if the datasource is reachable and the credentials are valid.
 7003        '''
 7004        self.hostname = hostname if hostname is not None else ''
 7005        self.id = id if id is not None else ''
 7006        '''
 7007         Unique identifier of the Resource.
 7008        '''
 7009        self.name = name if name is not None else ''
 7010        '''
 7011         Unique human-readable name of the Resource.
 7012        '''
 7013        self.override_database = override_database if override_database is not None else False
 7014        self.password = password if password is not None else ''
 7015        self.port = port if port is not None else 0
 7016        self.port_override = port_override if port_override is not None else 0
 7017        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7018        '''
 7019         ID of the secret store containing credentials for this resource, if any.
 7020        '''
 7021        self.server_name = server_name if server_name is not None else ''
 7022        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7023        '''
 7024         Tags is a map of key, value pairs.
 7025        '''
 7026        self.username = username if username is not None else ''
 7027
 7028    def __repr__(self):
 7029        return '<sdm.MTLSPostgres ' + \
 7030            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7031            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7032            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7033            'client_key: ' + repr(self.client_key) + ' ' +\
 7034            'database: ' + repr(self.database) + ' ' +\
 7035            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7036            'healthy: ' + repr(self.healthy) + ' ' +\
 7037            'hostname: ' + repr(self.hostname) + ' ' +\
 7038            'id: ' + repr(self.id) + ' ' +\
 7039            'name: ' + repr(self.name) + ' ' +\
 7040            'override_database: ' + repr(self.override_database) + ' ' +\
 7041            'password: ' + repr(self.password) + ' ' +\
 7042            'port: ' + repr(self.port) + ' ' +\
 7043            'port_override: ' + repr(self.port_override) + ' ' +\
 7044            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7045            'server_name: ' + repr(self.server_name) + ' ' +\
 7046            'tags: ' + repr(self.tags) + ' ' +\
 7047            'username: ' + repr(self.username) + ' ' +\
 7048            '>'
 7049
 7050    def to_dict(self):
 7051        return {
 7052            'bind_interface': self.bind_interface,
 7053            'certificate_authority': self.certificate_authority,
 7054            'client_certificate': self.client_certificate,
 7055            'client_key': self.client_key,
 7056            'database': self.database,
 7057            'egress_filter': self.egress_filter,
 7058            'healthy': self.healthy,
 7059            'hostname': self.hostname,
 7060            'id': self.id,
 7061            'name': self.name,
 7062            'override_database': self.override_database,
 7063            'password': self.password,
 7064            'port': self.port,
 7065            'port_override': self.port_override,
 7066            'secret_store_id': self.secret_store_id,
 7067            'server_name': self.server_name,
 7068            'tags': self.tags,
 7069            'username': self.username,
 7070        }
 7071
 7072    @classmethod
 7073    def from_dict(cls, d):
 7074        return cls(
 7075            bind_interface=d.get('bind_interface'),
 7076            certificate_authority=d.get('certificate_authority'),
 7077            client_certificate=d.get('client_certificate'),
 7078            client_key=d.get('client_key'),
 7079            database=d.get('database'),
 7080            egress_filter=d.get('egress_filter'),
 7081            healthy=d.get('healthy'),
 7082            hostname=d.get('hostname'),
 7083            id=d.get('id'),
 7084            name=d.get('name'),
 7085            override_database=d.get('override_database'),
 7086            password=d.get('password'),
 7087            port=d.get('port'),
 7088            port_override=d.get('port_override'),
 7089            secret_store_id=d.get('secret_store_id'),
 7090            server_name=d.get('server_name'),
 7091            tags=d.get('tags'),
 7092            username=d.get('username'),
 7093        )
 7094
 7095
 7096class Maria:
 7097    __slots__ = [
 7098        'bind_interface',
 7099        'database',
 7100        'egress_filter',
 7101        'healthy',
 7102        'hostname',
 7103        'id',
 7104        'name',
 7105        'password',
 7106        'port',
 7107        'port_override',
 7108        'secret_store_id',
 7109        'tags',
 7110        'username',
 7111    ]
 7112
 7113    def __init__(
 7114        self,
 7115        bind_interface=None,
 7116        database=None,
 7117        egress_filter=None,
 7118        healthy=None,
 7119        hostname=None,
 7120        id=None,
 7121        name=None,
 7122        password=None,
 7123        port=None,
 7124        port_override=None,
 7125        secret_store_id=None,
 7126        tags=None,
 7127        username=None,
 7128    ):
 7129        self.bind_interface = bind_interface if bind_interface is not None else ''
 7130        '''
 7131         Bind interface
 7132        '''
 7133        self.database = database if database is not None else ''
 7134        self.egress_filter = egress_filter if egress_filter is not None else ''
 7135        '''
 7136         A filter applied to the routing logic to pin datasource to nodes.
 7137        '''
 7138        self.healthy = healthy if healthy is not None else False
 7139        '''
 7140         True if the datasource is reachable and the credentials are valid.
 7141        '''
 7142        self.hostname = hostname if hostname is not None else ''
 7143        self.id = id if id is not None else ''
 7144        '''
 7145         Unique identifier of the Resource.
 7146        '''
 7147        self.name = name if name is not None else ''
 7148        '''
 7149         Unique human-readable name of the Resource.
 7150        '''
 7151        self.password = password if password is not None else ''
 7152        self.port = port if port is not None else 0
 7153        self.port_override = port_override if port_override is not None else 0
 7154        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7155        '''
 7156         ID of the secret store containing credentials for this resource, if any.
 7157        '''
 7158        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7159        '''
 7160         Tags is a map of key, value pairs.
 7161        '''
 7162        self.username = username if username is not None else ''
 7163
 7164    def __repr__(self):
 7165        return '<sdm.Maria ' + \
 7166            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7167            'database: ' + repr(self.database) + ' ' +\
 7168            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7169            'healthy: ' + repr(self.healthy) + ' ' +\
 7170            'hostname: ' + repr(self.hostname) + ' ' +\
 7171            'id: ' + repr(self.id) + ' ' +\
 7172            'name: ' + repr(self.name) + ' ' +\
 7173            'password: ' + repr(self.password) + ' ' +\
 7174            'port: ' + repr(self.port) + ' ' +\
 7175            'port_override: ' + repr(self.port_override) + ' ' +\
 7176            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7177            'tags: ' + repr(self.tags) + ' ' +\
 7178            'username: ' + repr(self.username) + ' ' +\
 7179            '>'
 7180
 7181    def to_dict(self):
 7182        return {
 7183            'bind_interface': self.bind_interface,
 7184            'database': self.database,
 7185            'egress_filter': self.egress_filter,
 7186            'healthy': self.healthy,
 7187            'hostname': self.hostname,
 7188            'id': self.id,
 7189            'name': self.name,
 7190            'password': self.password,
 7191            'port': self.port,
 7192            'port_override': self.port_override,
 7193            'secret_store_id': self.secret_store_id,
 7194            'tags': self.tags,
 7195            'username': self.username,
 7196        }
 7197
 7198    @classmethod
 7199    def from_dict(cls, d):
 7200        return cls(
 7201            bind_interface=d.get('bind_interface'),
 7202            database=d.get('database'),
 7203            egress_filter=d.get('egress_filter'),
 7204            healthy=d.get('healthy'),
 7205            hostname=d.get('hostname'),
 7206            id=d.get('id'),
 7207            name=d.get('name'),
 7208            password=d.get('password'),
 7209            port=d.get('port'),
 7210            port_override=d.get('port_override'),
 7211            secret_store_id=d.get('secret_store_id'),
 7212            tags=d.get('tags'),
 7213            username=d.get('username'),
 7214        )
 7215
 7216
 7217class Memcached:
 7218    __slots__ = [
 7219        'bind_interface',
 7220        'egress_filter',
 7221        'healthy',
 7222        'hostname',
 7223        'id',
 7224        'name',
 7225        'port',
 7226        'port_override',
 7227        'secret_store_id',
 7228        'tags',
 7229    ]
 7230
 7231    def __init__(
 7232        self,
 7233        bind_interface=None,
 7234        egress_filter=None,
 7235        healthy=None,
 7236        hostname=None,
 7237        id=None,
 7238        name=None,
 7239        port=None,
 7240        port_override=None,
 7241        secret_store_id=None,
 7242        tags=None,
 7243    ):
 7244        self.bind_interface = bind_interface if bind_interface is not None else ''
 7245        '''
 7246         Bind interface
 7247        '''
 7248        self.egress_filter = egress_filter if egress_filter is not None else ''
 7249        '''
 7250         A filter applied to the routing logic to pin datasource to nodes.
 7251        '''
 7252        self.healthy = healthy if healthy is not None else False
 7253        '''
 7254         True if the datasource is reachable and the credentials are valid.
 7255        '''
 7256        self.hostname = hostname if hostname is not None else ''
 7257        self.id = id if id is not None else ''
 7258        '''
 7259         Unique identifier of the Resource.
 7260        '''
 7261        self.name = name if name is not None else ''
 7262        '''
 7263         Unique human-readable name of the Resource.
 7264        '''
 7265        self.port = port if port is not None else 0
 7266        self.port_override = port_override if port_override is not None else 0
 7267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7268        '''
 7269         ID of the secret store containing credentials for this resource, if any.
 7270        '''
 7271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7272        '''
 7273         Tags is a map of key, value pairs.
 7274        '''
 7275
 7276    def __repr__(self):
 7277        return '<sdm.Memcached ' + \
 7278            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7279            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7280            'healthy: ' + repr(self.healthy) + ' ' +\
 7281            'hostname: ' + repr(self.hostname) + ' ' +\
 7282            'id: ' + repr(self.id) + ' ' +\
 7283            'name: ' + repr(self.name) + ' ' +\
 7284            'port: ' + repr(self.port) + ' ' +\
 7285            'port_override: ' + repr(self.port_override) + ' ' +\
 7286            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7287            'tags: ' + repr(self.tags) + ' ' +\
 7288            '>'
 7289
 7290    def to_dict(self):
 7291        return {
 7292            'bind_interface': self.bind_interface,
 7293            'egress_filter': self.egress_filter,
 7294            'healthy': self.healthy,
 7295            'hostname': self.hostname,
 7296            'id': self.id,
 7297            'name': self.name,
 7298            'port': self.port,
 7299            'port_override': self.port_override,
 7300            'secret_store_id': self.secret_store_id,
 7301            'tags': self.tags,
 7302        }
 7303
 7304    @classmethod
 7305    def from_dict(cls, d):
 7306        return cls(
 7307            bind_interface=d.get('bind_interface'),
 7308            egress_filter=d.get('egress_filter'),
 7309            healthy=d.get('healthy'),
 7310            hostname=d.get('hostname'),
 7311            id=d.get('id'),
 7312            name=d.get('name'),
 7313            port=d.get('port'),
 7314            port_override=d.get('port_override'),
 7315            secret_store_id=d.get('secret_store_id'),
 7316            tags=d.get('tags'),
 7317        )
 7318
 7319
 7320class Memsql:
 7321    __slots__ = [
 7322        'bind_interface',
 7323        'database',
 7324        'egress_filter',
 7325        'healthy',
 7326        'hostname',
 7327        'id',
 7328        'name',
 7329        'password',
 7330        'port',
 7331        'port_override',
 7332        'secret_store_id',
 7333        'tags',
 7334        'username',
 7335    ]
 7336
 7337    def __init__(
 7338        self,
 7339        bind_interface=None,
 7340        database=None,
 7341        egress_filter=None,
 7342        healthy=None,
 7343        hostname=None,
 7344        id=None,
 7345        name=None,
 7346        password=None,
 7347        port=None,
 7348        port_override=None,
 7349        secret_store_id=None,
 7350        tags=None,
 7351        username=None,
 7352    ):
 7353        self.bind_interface = bind_interface if bind_interface is not None else ''
 7354        '''
 7355         Bind interface
 7356        '''
 7357        self.database = database if database is not None else ''
 7358        self.egress_filter = egress_filter if egress_filter is not None else ''
 7359        '''
 7360         A filter applied to the routing logic to pin datasource to nodes.
 7361        '''
 7362        self.healthy = healthy if healthy is not None else False
 7363        '''
 7364         True if the datasource is reachable and the credentials are valid.
 7365        '''
 7366        self.hostname = hostname if hostname is not None else ''
 7367        self.id = id if id is not None else ''
 7368        '''
 7369         Unique identifier of the Resource.
 7370        '''
 7371        self.name = name if name is not None else ''
 7372        '''
 7373         Unique human-readable name of the Resource.
 7374        '''
 7375        self.password = password if password is not None else ''
 7376        self.port = port if port is not None else 0
 7377        self.port_override = port_override if port_override is not None else 0
 7378        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7379        '''
 7380         ID of the secret store containing credentials for this resource, if any.
 7381        '''
 7382        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7383        '''
 7384         Tags is a map of key, value pairs.
 7385        '''
 7386        self.username = username if username is not None else ''
 7387
 7388    def __repr__(self):
 7389        return '<sdm.Memsql ' + \
 7390            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7391            'database: ' + repr(self.database) + ' ' +\
 7392            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7393            'healthy: ' + repr(self.healthy) + ' ' +\
 7394            'hostname: ' + repr(self.hostname) + ' ' +\
 7395            'id: ' + repr(self.id) + ' ' +\
 7396            'name: ' + repr(self.name) + ' ' +\
 7397            'password: ' + repr(self.password) + ' ' +\
 7398            'port: ' + repr(self.port) + ' ' +\
 7399            'port_override: ' + repr(self.port_override) + ' ' +\
 7400            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7401            'tags: ' + repr(self.tags) + ' ' +\
 7402            'username: ' + repr(self.username) + ' ' +\
 7403            '>'
 7404
 7405    def to_dict(self):
 7406        return {
 7407            'bind_interface': self.bind_interface,
 7408            'database': self.database,
 7409            'egress_filter': self.egress_filter,
 7410            'healthy': self.healthy,
 7411            'hostname': self.hostname,
 7412            'id': self.id,
 7413            'name': self.name,
 7414            'password': self.password,
 7415            'port': self.port,
 7416            'port_override': self.port_override,
 7417            'secret_store_id': self.secret_store_id,
 7418            'tags': self.tags,
 7419            'username': self.username,
 7420        }
 7421
 7422    @classmethod
 7423    def from_dict(cls, d):
 7424        return cls(
 7425            bind_interface=d.get('bind_interface'),
 7426            database=d.get('database'),
 7427            egress_filter=d.get('egress_filter'),
 7428            healthy=d.get('healthy'),
 7429            hostname=d.get('hostname'),
 7430            id=d.get('id'),
 7431            name=d.get('name'),
 7432            password=d.get('password'),
 7433            port=d.get('port'),
 7434            port_override=d.get('port_override'),
 7435            secret_store_id=d.get('secret_store_id'),
 7436            tags=d.get('tags'),
 7437            username=d.get('username'),
 7438        )
 7439
 7440
 7441class MongoHost:
 7442    '''
 7443    MongoHost is currently unstable, and its API may change, or it may be removed,
 7444    without a major version bump.
 7445    '''
 7446    __slots__ = [
 7447        'auth_database',
 7448        'bind_interface',
 7449        'egress_filter',
 7450        'healthy',
 7451        'hostname',
 7452        'id',
 7453        'name',
 7454        'password',
 7455        'port',
 7456        'port_override',
 7457        'secret_store_id',
 7458        'tags',
 7459        'tls_required',
 7460        'username',
 7461    ]
 7462
 7463    def __init__(
 7464        self,
 7465        auth_database=None,
 7466        bind_interface=None,
 7467        egress_filter=None,
 7468        healthy=None,
 7469        hostname=None,
 7470        id=None,
 7471        name=None,
 7472        password=None,
 7473        port=None,
 7474        port_override=None,
 7475        secret_store_id=None,
 7476        tags=None,
 7477        tls_required=None,
 7478        username=None,
 7479    ):
 7480        self.auth_database = auth_database if auth_database is not None else ''
 7481        self.bind_interface = bind_interface if bind_interface is not None else ''
 7482        '''
 7483         Bind interface
 7484        '''
 7485        self.egress_filter = egress_filter if egress_filter is not None else ''
 7486        '''
 7487         A filter applied to the routing logic to pin datasource to nodes.
 7488        '''
 7489        self.healthy = healthy if healthy is not None else False
 7490        '''
 7491         True if the datasource is reachable and the credentials are valid.
 7492        '''
 7493        self.hostname = hostname if hostname is not None else ''
 7494        self.id = id if id is not None else ''
 7495        '''
 7496         Unique identifier of the Resource.
 7497        '''
 7498        self.name = name if name is not None else ''
 7499        '''
 7500         Unique human-readable name of the Resource.
 7501        '''
 7502        self.password = password if password is not None else ''
 7503        self.port = port if port is not None else 0
 7504        self.port_override = port_override if port_override is not None else 0
 7505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7506        '''
 7507         ID of the secret store containing credentials for this resource, if any.
 7508        '''
 7509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7510        '''
 7511         Tags is a map of key, value pairs.
 7512        '''
 7513        self.tls_required = tls_required if tls_required is not None else False
 7514        self.username = username if username is not None else ''
 7515
 7516    def __repr__(self):
 7517        return '<sdm.MongoHost ' + \
 7518            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7521            'healthy: ' + repr(self.healthy) + ' ' +\
 7522            'hostname: ' + repr(self.hostname) + ' ' +\
 7523            'id: ' + repr(self.id) + ' ' +\
 7524            'name: ' + repr(self.name) + ' ' +\
 7525            'password: ' + repr(self.password) + ' ' +\
 7526            'port: ' + repr(self.port) + ' ' +\
 7527            'port_override: ' + repr(self.port_override) + ' ' +\
 7528            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7529            'tags: ' + repr(self.tags) + ' ' +\
 7530            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7531            'username: ' + repr(self.username) + ' ' +\
 7532            '>'
 7533
 7534    def to_dict(self):
 7535        return {
 7536            'auth_database': self.auth_database,
 7537            'bind_interface': self.bind_interface,
 7538            'egress_filter': self.egress_filter,
 7539            'healthy': self.healthy,
 7540            'hostname': self.hostname,
 7541            'id': self.id,
 7542            'name': self.name,
 7543            'password': self.password,
 7544            'port': self.port,
 7545            'port_override': self.port_override,
 7546            'secret_store_id': self.secret_store_id,
 7547            'tags': self.tags,
 7548            'tls_required': self.tls_required,
 7549            'username': self.username,
 7550        }
 7551
 7552    @classmethod
 7553    def from_dict(cls, d):
 7554        return cls(
 7555            auth_database=d.get('auth_database'),
 7556            bind_interface=d.get('bind_interface'),
 7557            egress_filter=d.get('egress_filter'),
 7558            healthy=d.get('healthy'),
 7559            hostname=d.get('hostname'),
 7560            id=d.get('id'),
 7561            name=d.get('name'),
 7562            password=d.get('password'),
 7563            port=d.get('port'),
 7564            port_override=d.get('port_override'),
 7565            secret_store_id=d.get('secret_store_id'),
 7566            tags=d.get('tags'),
 7567            tls_required=d.get('tls_required'),
 7568            username=d.get('username'),
 7569        )
 7570
 7571
 7572class MongoLegacyHost:
 7573    __slots__ = [
 7574        'auth_database',
 7575        'bind_interface',
 7576        'egress_filter',
 7577        'healthy',
 7578        'hostname',
 7579        'id',
 7580        'name',
 7581        'password',
 7582        'port',
 7583        'port_override',
 7584        'replica_set',
 7585        'secret_store_id',
 7586        'tags',
 7587        'tls_required',
 7588        'username',
 7589    ]
 7590
 7591    def __init__(
 7592        self,
 7593        auth_database=None,
 7594        bind_interface=None,
 7595        egress_filter=None,
 7596        healthy=None,
 7597        hostname=None,
 7598        id=None,
 7599        name=None,
 7600        password=None,
 7601        port=None,
 7602        port_override=None,
 7603        replica_set=None,
 7604        secret_store_id=None,
 7605        tags=None,
 7606        tls_required=None,
 7607        username=None,
 7608    ):
 7609        self.auth_database = auth_database if auth_database is not None else ''
 7610        self.bind_interface = bind_interface if bind_interface is not None else ''
 7611        '''
 7612         Bind interface
 7613        '''
 7614        self.egress_filter = egress_filter if egress_filter is not None else ''
 7615        '''
 7616         A filter applied to the routing logic to pin datasource to nodes.
 7617        '''
 7618        self.healthy = healthy if healthy is not None else False
 7619        '''
 7620         True if the datasource is reachable and the credentials are valid.
 7621        '''
 7622        self.hostname = hostname if hostname is not None else ''
 7623        self.id = id if id is not None else ''
 7624        '''
 7625         Unique identifier of the Resource.
 7626        '''
 7627        self.name = name if name is not None else ''
 7628        '''
 7629         Unique human-readable name of the Resource.
 7630        '''
 7631        self.password = password if password is not None else ''
 7632        self.port = port if port is not None else 0
 7633        self.port_override = port_override if port_override is not None else 0
 7634        self.replica_set = replica_set if replica_set is not None else ''
 7635        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7636        '''
 7637         ID of the secret store containing credentials for this resource, if any.
 7638        '''
 7639        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7640        '''
 7641         Tags is a map of key, value pairs.
 7642        '''
 7643        self.tls_required = tls_required if tls_required is not None else False
 7644        self.username = username if username is not None else ''
 7645
 7646    def __repr__(self):
 7647        return '<sdm.MongoLegacyHost ' + \
 7648            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7649            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7650            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7651            'healthy: ' + repr(self.healthy) + ' ' +\
 7652            'hostname: ' + repr(self.hostname) + ' ' +\
 7653            'id: ' + repr(self.id) + ' ' +\
 7654            'name: ' + repr(self.name) + ' ' +\
 7655            'password: ' + repr(self.password) + ' ' +\
 7656            'port: ' + repr(self.port) + ' ' +\
 7657            'port_override: ' + repr(self.port_override) + ' ' +\
 7658            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7659            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7660            'tags: ' + repr(self.tags) + ' ' +\
 7661            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7662            'username: ' + repr(self.username) + ' ' +\
 7663            '>'
 7664
 7665    def to_dict(self):
 7666        return {
 7667            'auth_database': self.auth_database,
 7668            'bind_interface': self.bind_interface,
 7669            'egress_filter': self.egress_filter,
 7670            'healthy': self.healthy,
 7671            'hostname': self.hostname,
 7672            'id': self.id,
 7673            'name': self.name,
 7674            'password': self.password,
 7675            'port': self.port,
 7676            'port_override': self.port_override,
 7677            'replica_set': self.replica_set,
 7678            'secret_store_id': self.secret_store_id,
 7679            'tags': self.tags,
 7680            'tls_required': self.tls_required,
 7681            'username': self.username,
 7682        }
 7683
 7684    @classmethod
 7685    def from_dict(cls, d):
 7686        return cls(
 7687            auth_database=d.get('auth_database'),
 7688            bind_interface=d.get('bind_interface'),
 7689            egress_filter=d.get('egress_filter'),
 7690            healthy=d.get('healthy'),
 7691            hostname=d.get('hostname'),
 7692            id=d.get('id'),
 7693            name=d.get('name'),
 7694            password=d.get('password'),
 7695            port=d.get('port'),
 7696            port_override=d.get('port_override'),
 7697            replica_set=d.get('replica_set'),
 7698            secret_store_id=d.get('secret_store_id'),
 7699            tags=d.get('tags'),
 7700            tls_required=d.get('tls_required'),
 7701            username=d.get('username'),
 7702        )
 7703
 7704
 7705class MongoLegacyReplicaset:
 7706    __slots__ = [
 7707        'auth_database',
 7708        'bind_interface',
 7709        'connect_to_replica',
 7710        'egress_filter',
 7711        'healthy',
 7712        'hostname',
 7713        'id',
 7714        'name',
 7715        'password',
 7716        'port',
 7717        'port_override',
 7718        'replica_set',
 7719        'secret_store_id',
 7720        'tags',
 7721        'tls_required',
 7722        'username',
 7723    ]
 7724
 7725    def __init__(
 7726        self,
 7727        auth_database=None,
 7728        bind_interface=None,
 7729        connect_to_replica=None,
 7730        egress_filter=None,
 7731        healthy=None,
 7732        hostname=None,
 7733        id=None,
 7734        name=None,
 7735        password=None,
 7736        port=None,
 7737        port_override=None,
 7738        replica_set=None,
 7739        secret_store_id=None,
 7740        tags=None,
 7741        tls_required=None,
 7742        username=None,
 7743    ):
 7744        self.auth_database = auth_database if auth_database is not None else ''
 7745        self.bind_interface = bind_interface if bind_interface is not None else ''
 7746        '''
 7747         Bind interface
 7748        '''
 7749        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7750        self.egress_filter = egress_filter if egress_filter is not None else ''
 7751        '''
 7752         A filter applied to the routing logic to pin datasource to nodes.
 7753        '''
 7754        self.healthy = healthy if healthy is not None else False
 7755        '''
 7756         True if the datasource is reachable and the credentials are valid.
 7757        '''
 7758        self.hostname = hostname if hostname is not None else ''
 7759        self.id = id if id is not None else ''
 7760        '''
 7761         Unique identifier of the Resource.
 7762        '''
 7763        self.name = name if name is not None else ''
 7764        '''
 7765         Unique human-readable name of the Resource.
 7766        '''
 7767        self.password = password if password is not None else ''
 7768        self.port = port if port is not None else 0
 7769        self.port_override = port_override if port_override is not None else 0
 7770        self.replica_set = replica_set if replica_set is not None else ''
 7771        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7772        '''
 7773         ID of the secret store containing credentials for this resource, if any.
 7774        '''
 7775        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7776        '''
 7777         Tags is a map of key, value pairs.
 7778        '''
 7779        self.tls_required = tls_required if tls_required is not None else False
 7780        self.username = username if username is not None else ''
 7781
 7782    def __repr__(self):
 7783        return '<sdm.MongoLegacyReplicaset ' + \
 7784            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7785            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7786            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7787            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7788            'healthy: ' + repr(self.healthy) + ' ' +\
 7789            'hostname: ' + repr(self.hostname) + ' ' +\
 7790            'id: ' + repr(self.id) + ' ' +\
 7791            'name: ' + repr(self.name) + ' ' +\
 7792            'password: ' + repr(self.password) + ' ' +\
 7793            'port: ' + repr(self.port) + ' ' +\
 7794            'port_override: ' + repr(self.port_override) + ' ' +\
 7795            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7796            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7797            'tags: ' + repr(self.tags) + ' ' +\
 7798            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7799            'username: ' + repr(self.username) + ' ' +\
 7800            '>'
 7801
 7802    def to_dict(self):
 7803        return {
 7804            'auth_database': self.auth_database,
 7805            'bind_interface': self.bind_interface,
 7806            'connect_to_replica': self.connect_to_replica,
 7807            'egress_filter': self.egress_filter,
 7808            'healthy': self.healthy,
 7809            'hostname': self.hostname,
 7810            'id': self.id,
 7811            'name': self.name,
 7812            'password': self.password,
 7813            'port': self.port,
 7814            'port_override': self.port_override,
 7815            'replica_set': self.replica_set,
 7816            'secret_store_id': self.secret_store_id,
 7817            'tags': self.tags,
 7818            'tls_required': self.tls_required,
 7819            'username': self.username,
 7820        }
 7821
 7822    @classmethod
 7823    def from_dict(cls, d):
 7824        return cls(
 7825            auth_database=d.get('auth_database'),
 7826            bind_interface=d.get('bind_interface'),
 7827            connect_to_replica=d.get('connect_to_replica'),
 7828            egress_filter=d.get('egress_filter'),
 7829            healthy=d.get('healthy'),
 7830            hostname=d.get('hostname'),
 7831            id=d.get('id'),
 7832            name=d.get('name'),
 7833            password=d.get('password'),
 7834            port=d.get('port'),
 7835            port_override=d.get('port_override'),
 7836            replica_set=d.get('replica_set'),
 7837            secret_store_id=d.get('secret_store_id'),
 7838            tags=d.get('tags'),
 7839            tls_required=d.get('tls_required'),
 7840            username=d.get('username'),
 7841        )
 7842
 7843
 7844class MongoReplicaSet:
 7845    '''
 7846    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7847    without a major version bump.
 7848    '''
 7849    __slots__ = [
 7850        'auth_database',
 7851        'bind_interface',
 7852        'connect_to_replica',
 7853        'egress_filter',
 7854        'healthy',
 7855        'hostname',
 7856        'id',
 7857        'name',
 7858        'password',
 7859        'port',
 7860        'port_override',
 7861        'replica_set',
 7862        'secret_store_id',
 7863        'tags',
 7864        'tls_required',
 7865        'username',
 7866    ]
 7867
 7868    def __init__(
 7869        self,
 7870        auth_database=None,
 7871        bind_interface=None,
 7872        connect_to_replica=None,
 7873        egress_filter=None,
 7874        healthy=None,
 7875        hostname=None,
 7876        id=None,
 7877        name=None,
 7878        password=None,
 7879        port=None,
 7880        port_override=None,
 7881        replica_set=None,
 7882        secret_store_id=None,
 7883        tags=None,
 7884        tls_required=None,
 7885        username=None,
 7886    ):
 7887        self.auth_database = auth_database if auth_database is not None else ''
 7888        self.bind_interface = bind_interface if bind_interface is not None else ''
 7889        '''
 7890         Bind interface
 7891        '''
 7892        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7893        self.egress_filter = egress_filter if egress_filter is not None else ''
 7894        '''
 7895         A filter applied to the routing logic to pin datasource to nodes.
 7896        '''
 7897        self.healthy = healthy if healthy is not None else False
 7898        '''
 7899         True if the datasource is reachable and the credentials are valid.
 7900        '''
 7901        self.hostname = hostname if hostname is not None else ''
 7902        self.id = id if id is not None else ''
 7903        '''
 7904         Unique identifier of the Resource.
 7905        '''
 7906        self.name = name if name is not None else ''
 7907        '''
 7908         Unique human-readable name of the Resource.
 7909        '''
 7910        self.password = password if password is not None else ''
 7911        self.port = port if port is not None else 0
 7912        self.port_override = port_override if port_override is not None else 0
 7913        self.replica_set = replica_set if replica_set is not None else ''
 7914        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7915        '''
 7916         ID of the secret store containing credentials for this resource, if any.
 7917        '''
 7918        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7919        '''
 7920         Tags is a map of key, value pairs.
 7921        '''
 7922        self.tls_required = tls_required if tls_required is not None else False
 7923        self.username = username if username is not None else ''
 7924
 7925    def __repr__(self):
 7926        return '<sdm.MongoReplicaSet ' + \
 7927            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7928            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7929            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7930            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7931            'healthy: ' + repr(self.healthy) + ' ' +\
 7932            'hostname: ' + repr(self.hostname) + ' ' +\
 7933            'id: ' + repr(self.id) + ' ' +\
 7934            'name: ' + repr(self.name) + ' ' +\
 7935            'password: ' + repr(self.password) + ' ' +\
 7936            'port: ' + repr(self.port) + ' ' +\
 7937            'port_override: ' + repr(self.port_override) + ' ' +\
 7938            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7939            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7940            'tags: ' + repr(self.tags) + ' ' +\
 7941            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7942            'username: ' + repr(self.username) + ' ' +\
 7943            '>'
 7944
 7945    def to_dict(self):
 7946        return {
 7947            'auth_database': self.auth_database,
 7948            'bind_interface': self.bind_interface,
 7949            'connect_to_replica': self.connect_to_replica,
 7950            'egress_filter': self.egress_filter,
 7951            'healthy': self.healthy,
 7952            'hostname': self.hostname,
 7953            'id': self.id,
 7954            'name': self.name,
 7955            'password': self.password,
 7956            'port': self.port,
 7957            'port_override': self.port_override,
 7958            'replica_set': self.replica_set,
 7959            'secret_store_id': self.secret_store_id,
 7960            'tags': self.tags,
 7961            'tls_required': self.tls_required,
 7962            'username': self.username,
 7963        }
 7964
 7965    @classmethod
 7966    def from_dict(cls, d):
 7967        return cls(
 7968            auth_database=d.get('auth_database'),
 7969            bind_interface=d.get('bind_interface'),
 7970            connect_to_replica=d.get('connect_to_replica'),
 7971            egress_filter=d.get('egress_filter'),
 7972            healthy=d.get('healthy'),
 7973            hostname=d.get('hostname'),
 7974            id=d.get('id'),
 7975            name=d.get('name'),
 7976            password=d.get('password'),
 7977            port=d.get('port'),
 7978            port_override=d.get('port_override'),
 7979            replica_set=d.get('replica_set'),
 7980            secret_store_id=d.get('secret_store_id'),
 7981            tags=d.get('tags'),
 7982            tls_required=d.get('tls_required'),
 7983            username=d.get('username'),
 7984        )
 7985
 7986
 7987class MongoShardedCluster:
 7988    '''
 7989    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 7990    without a major version bump.
 7991    '''
 7992    __slots__ = [
 7993        'auth_database',
 7994        'bind_interface',
 7995        'egress_filter',
 7996        'healthy',
 7997        'hostname',
 7998        'id',
 7999        'name',
 8000        'password',
 8001        'port_override',
 8002        'secret_store_id',
 8003        'tags',
 8004        'tls_required',
 8005        'username',
 8006    ]
 8007
 8008    def __init__(
 8009        self,
 8010        auth_database=None,
 8011        bind_interface=None,
 8012        egress_filter=None,
 8013        healthy=None,
 8014        hostname=None,
 8015        id=None,
 8016        name=None,
 8017        password=None,
 8018        port_override=None,
 8019        secret_store_id=None,
 8020        tags=None,
 8021        tls_required=None,
 8022        username=None,
 8023    ):
 8024        self.auth_database = auth_database if auth_database is not None else ''
 8025        self.bind_interface = bind_interface if bind_interface is not None else ''
 8026        '''
 8027         Bind interface
 8028        '''
 8029        self.egress_filter = egress_filter if egress_filter is not None else ''
 8030        '''
 8031         A filter applied to the routing logic to pin datasource to nodes.
 8032        '''
 8033        self.healthy = healthy if healthy is not None else False
 8034        '''
 8035         True if the datasource is reachable and the credentials are valid.
 8036        '''
 8037        self.hostname = hostname if hostname is not None else ''
 8038        self.id = id if id is not None else ''
 8039        '''
 8040         Unique identifier of the Resource.
 8041        '''
 8042        self.name = name if name is not None else ''
 8043        '''
 8044         Unique human-readable name of the Resource.
 8045        '''
 8046        self.password = password if password is not None else ''
 8047        self.port_override = port_override if port_override is not None else 0
 8048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8049        '''
 8050         ID of the secret store containing credentials for this resource, if any.
 8051        '''
 8052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8053        '''
 8054         Tags is a map of key, value pairs.
 8055        '''
 8056        self.tls_required = tls_required if tls_required is not None else False
 8057        self.username = username if username is not None else ''
 8058
 8059    def __repr__(self):
 8060        return '<sdm.MongoShardedCluster ' + \
 8061            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8062            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8063            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8064            'healthy: ' + repr(self.healthy) + ' ' +\
 8065            'hostname: ' + repr(self.hostname) + ' ' +\
 8066            'id: ' + repr(self.id) + ' ' +\
 8067            'name: ' + repr(self.name) + ' ' +\
 8068            'password: ' + repr(self.password) + ' ' +\
 8069            'port_override: ' + repr(self.port_override) + ' ' +\
 8070            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8071            'tags: ' + repr(self.tags) + ' ' +\
 8072            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8073            'username: ' + repr(self.username) + ' ' +\
 8074            '>'
 8075
 8076    def to_dict(self):
 8077        return {
 8078            'auth_database': self.auth_database,
 8079            'bind_interface': self.bind_interface,
 8080            'egress_filter': self.egress_filter,
 8081            'healthy': self.healthy,
 8082            'hostname': self.hostname,
 8083            'id': self.id,
 8084            'name': self.name,
 8085            'password': self.password,
 8086            'port_override': self.port_override,
 8087            'secret_store_id': self.secret_store_id,
 8088            'tags': self.tags,
 8089            'tls_required': self.tls_required,
 8090            'username': self.username,
 8091        }
 8092
 8093    @classmethod
 8094    def from_dict(cls, d):
 8095        return cls(
 8096            auth_database=d.get('auth_database'),
 8097            bind_interface=d.get('bind_interface'),
 8098            egress_filter=d.get('egress_filter'),
 8099            healthy=d.get('healthy'),
 8100            hostname=d.get('hostname'),
 8101            id=d.get('id'),
 8102            name=d.get('name'),
 8103            password=d.get('password'),
 8104            port_override=d.get('port_override'),
 8105            secret_store_id=d.get('secret_store_id'),
 8106            tags=d.get('tags'),
 8107            tls_required=d.get('tls_required'),
 8108            username=d.get('username'),
 8109        )
 8110
 8111
 8112class Mysql:
 8113    __slots__ = [
 8114        'bind_interface',
 8115        'database',
 8116        'egress_filter',
 8117        'healthy',
 8118        'hostname',
 8119        'id',
 8120        'name',
 8121        'password',
 8122        'port',
 8123        'port_override',
 8124        'secret_store_id',
 8125        'tags',
 8126        'username',
 8127    ]
 8128
 8129    def __init__(
 8130        self,
 8131        bind_interface=None,
 8132        database=None,
 8133        egress_filter=None,
 8134        healthy=None,
 8135        hostname=None,
 8136        id=None,
 8137        name=None,
 8138        password=None,
 8139        port=None,
 8140        port_override=None,
 8141        secret_store_id=None,
 8142        tags=None,
 8143        username=None,
 8144    ):
 8145        self.bind_interface = bind_interface if bind_interface is not None else ''
 8146        '''
 8147         Bind interface
 8148        '''
 8149        self.database = database if database is not None else ''
 8150        self.egress_filter = egress_filter if egress_filter is not None else ''
 8151        '''
 8152         A filter applied to the routing logic to pin datasource to nodes.
 8153        '''
 8154        self.healthy = healthy if healthy is not None else False
 8155        '''
 8156         True if the datasource is reachable and the credentials are valid.
 8157        '''
 8158        self.hostname = hostname if hostname is not None else ''
 8159        self.id = id if id is not None else ''
 8160        '''
 8161         Unique identifier of the Resource.
 8162        '''
 8163        self.name = name if name is not None else ''
 8164        '''
 8165         Unique human-readable name of the Resource.
 8166        '''
 8167        self.password = password if password is not None else ''
 8168        self.port = port if port is not None else 0
 8169        self.port_override = port_override if port_override is not None else 0
 8170        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8171        '''
 8172         ID of the secret store containing credentials for this resource, if any.
 8173        '''
 8174        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8175        '''
 8176         Tags is a map of key, value pairs.
 8177        '''
 8178        self.username = username if username is not None else ''
 8179
 8180    def __repr__(self):
 8181        return '<sdm.Mysql ' + \
 8182            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8183            'database: ' + repr(self.database) + ' ' +\
 8184            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8185            'healthy: ' + repr(self.healthy) + ' ' +\
 8186            'hostname: ' + repr(self.hostname) + ' ' +\
 8187            'id: ' + repr(self.id) + ' ' +\
 8188            'name: ' + repr(self.name) + ' ' +\
 8189            'password: ' + repr(self.password) + ' ' +\
 8190            'port: ' + repr(self.port) + ' ' +\
 8191            'port_override: ' + repr(self.port_override) + ' ' +\
 8192            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8193            'tags: ' + repr(self.tags) + ' ' +\
 8194            'username: ' + repr(self.username) + ' ' +\
 8195            '>'
 8196
 8197    def to_dict(self):
 8198        return {
 8199            'bind_interface': self.bind_interface,
 8200            'database': self.database,
 8201            'egress_filter': self.egress_filter,
 8202            'healthy': self.healthy,
 8203            'hostname': self.hostname,
 8204            'id': self.id,
 8205            'name': self.name,
 8206            'password': self.password,
 8207            'port': self.port,
 8208            'port_override': self.port_override,
 8209            'secret_store_id': self.secret_store_id,
 8210            'tags': self.tags,
 8211            'username': self.username,
 8212        }
 8213
 8214    @classmethod
 8215    def from_dict(cls, d):
 8216        return cls(
 8217            bind_interface=d.get('bind_interface'),
 8218            database=d.get('database'),
 8219            egress_filter=d.get('egress_filter'),
 8220            healthy=d.get('healthy'),
 8221            hostname=d.get('hostname'),
 8222            id=d.get('id'),
 8223            name=d.get('name'),
 8224            password=d.get('password'),
 8225            port=d.get('port'),
 8226            port_override=d.get('port_override'),
 8227            secret_store_id=d.get('secret_store_id'),
 8228            tags=d.get('tags'),
 8229            username=d.get('username'),
 8230        )
 8231
 8232
 8233class Neptune:
 8234    __slots__ = [
 8235        'bind_interface',
 8236        'egress_filter',
 8237        'endpoint',
 8238        'healthy',
 8239        'id',
 8240        'name',
 8241        'port',
 8242        'port_override',
 8243        'secret_store_id',
 8244        'tags',
 8245    ]
 8246
 8247    def __init__(
 8248        self,
 8249        bind_interface=None,
 8250        egress_filter=None,
 8251        endpoint=None,
 8252        healthy=None,
 8253        id=None,
 8254        name=None,
 8255        port=None,
 8256        port_override=None,
 8257        secret_store_id=None,
 8258        tags=None,
 8259    ):
 8260        self.bind_interface = bind_interface if bind_interface is not None else ''
 8261        '''
 8262         Bind interface
 8263        '''
 8264        self.egress_filter = egress_filter if egress_filter is not None else ''
 8265        '''
 8266         A filter applied to the routing logic to pin datasource to nodes.
 8267        '''
 8268        self.endpoint = endpoint if endpoint is not None else ''
 8269        self.healthy = healthy if healthy is not None else False
 8270        '''
 8271         True if the datasource is reachable and the credentials are valid.
 8272        '''
 8273        self.id = id if id is not None else ''
 8274        '''
 8275         Unique identifier of the Resource.
 8276        '''
 8277        self.name = name if name is not None else ''
 8278        '''
 8279         Unique human-readable name of the Resource.
 8280        '''
 8281        self.port = port if port is not None else 0
 8282        self.port_override = port_override if port_override is not None else 0
 8283        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8284        '''
 8285         ID of the secret store containing credentials for this resource, if any.
 8286        '''
 8287        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8288        '''
 8289         Tags is a map of key, value pairs.
 8290        '''
 8291
 8292    def __repr__(self):
 8293        return '<sdm.Neptune ' + \
 8294            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8295            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8296            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8297            'healthy: ' + repr(self.healthy) + ' ' +\
 8298            'id: ' + repr(self.id) + ' ' +\
 8299            'name: ' + repr(self.name) + ' ' +\
 8300            'port: ' + repr(self.port) + ' ' +\
 8301            'port_override: ' + repr(self.port_override) + ' ' +\
 8302            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8303            'tags: ' + repr(self.tags) + ' ' +\
 8304            '>'
 8305
 8306    def to_dict(self):
 8307        return {
 8308            'bind_interface': self.bind_interface,
 8309            'egress_filter': self.egress_filter,
 8310            'endpoint': self.endpoint,
 8311            'healthy': self.healthy,
 8312            'id': self.id,
 8313            'name': self.name,
 8314            'port': self.port,
 8315            'port_override': self.port_override,
 8316            'secret_store_id': self.secret_store_id,
 8317            'tags': self.tags,
 8318        }
 8319
 8320    @classmethod
 8321    def from_dict(cls, d):
 8322        return cls(
 8323            bind_interface=d.get('bind_interface'),
 8324            egress_filter=d.get('egress_filter'),
 8325            endpoint=d.get('endpoint'),
 8326            healthy=d.get('healthy'),
 8327            id=d.get('id'),
 8328            name=d.get('name'),
 8329            port=d.get('port'),
 8330            port_override=d.get('port_override'),
 8331            secret_store_id=d.get('secret_store_id'),
 8332            tags=d.get('tags'),
 8333        )
 8334
 8335
 8336class NeptuneIAM:
 8337    __slots__ = [
 8338        'access_key',
 8339        'bind_interface',
 8340        'egress_filter',
 8341        'endpoint',
 8342        'healthy',
 8343        'id',
 8344        'name',
 8345        'port',
 8346        'port_override',
 8347        'region',
 8348        'role_arn',
 8349        'role_external_id',
 8350        'secret_access_key',
 8351        'secret_store_id',
 8352        'tags',
 8353    ]
 8354
 8355    def __init__(
 8356        self,
 8357        access_key=None,
 8358        bind_interface=None,
 8359        egress_filter=None,
 8360        endpoint=None,
 8361        healthy=None,
 8362        id=None,
 8363        name=None,
 8364        port=None,
 8365        port_override=None,
 8366        region=None,
 8367        role_arn=None,
 8368        role_external_id=None,
 8369        secret_access_key=None,
 8370        secret_store_id=None,
 8371        tags=None,
 8372    ):
 8373        self.access_key = access_key if access_key is not None else ''
 8374        self.bind_interface = bind_interface if bind_interface is not None else ''
 8375        '''
 8376         Bind interface
 8377        '''
 8378        self.egress_filter = egress_filter if egress_filter is not None else ''
 8379        '''
 8380         A filter applied to the routing logic to pin datasource to nodes.
 8381        '''
 8382        self.endpoint = endpoint if endpoint is not None else ''
 8383        self.healthy = healthy if healthy is not None else False
 8384        '''
 8385         True if the datasource is reachable and the credentials are valid.
 8386        '''
 8387        self.id = id if id is not None else ''
 8388        '''
 8389         Unique identifier of the Resource.
 8390        '''
 8391        self.name = name if name is not None else ''
 8392        '''
 8393         Unique human-readable name of the Resource.
 8394        '''
 8395        self.port = port if port is not None else 0
 8396        self.port_override = port_override if port_override is not None else 0
 8397        self.region = region if region is not None else ''
 8398        self.role_arn = role_arn if role_arn is not None else ''
 8399        self.role_external_id = role_external_id if role_external_id is not None else ''
 8400        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8401        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8402        '''
 8403         ID of the secret store containing credentials for this resource, if any.
 8404        '''
 8405        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8406        '''
 8407         Tags is a map of key, value pairs.
 8408        '''
 8409
 8410    def __repr__(self):
 8411        return '<sdm.NeptuneIAM ' + \
 8412            'access_key: ' + repr(self.access_key) + ' ' +\
 8413            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8414            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8415            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8416            'healthy: ' + repr(self.healthy) + ' ' +\
 8417            'id: ' + repr(self.id) + ' ' +\
 8418            'name: ' + repr(self.name) + ' ' +\
 8419            'port: ' + repr(self.port) + ' ' +\
 8420            'port_override: ' + repr(self.port_override) + ' ' +\
 8421            'region: ' + repr(self.region) + ' ' +\
 8422            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8423            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8424            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8425            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8426            'tags: ' + repr(self.tags) + ' ' +\
 8427            '>'
 8428
 8429    def to_dict(self):
 8430        return {
 8431            'access_key': self.access_key,
 8432            'bind_interface': self.bind_interface,
 8433            'egress_filter': self.egress_filter,
 8434            'endpoint': self.endpoint,
 8435            'healthy': self.healthy,
 8436            'id': self.id,
 8437            'name': self.name,
 8438            'port': self.port,
 8439            'port_override': self.port_override,
 8440            'region': self.region,
 8441            'role_arn': self.role_arn,
 8442            'role_external_id': self.role_external_id,
 8443            'secret_access_key': self.secret_access_key,
 8444            'secret_store_id': self.secret_store_id,
 8445            'tags': self.tags,
 8446        }
 8447
 8448    @classmethod
 8449    def from_dict(cls, d):
 8450        return cls(
 8451            access_key=d.get('access_key'),
 8452            bind_interface=d.get('bind_interface'),
 8453            egress_filter=d.get('egress_filter'),
 8454            endpoint=d.get('endpoint'),
 8455            healthy=d.get('healthy'),
 8456            id=d.get('id'),
 8457            name=d.get('name'),
 8458            port=d.get('port'),
 8459            port_override=d.get('port_override'),
 8460            region=d.get('region'),
 8461            role_arn=d.get('role_arn'),
 8462            role_external_id=d.get('role_external_id'),
 8463            secret_access_key=d.get('secret_access_key'),
 8464            secret_store_id=d.get('secret_store_id'),
 8465            tags=d.get('tags'),
 8466        )
 8467
 8468
 8469class NodeCreateResponse:
 8470    '''
 8471         NodeCreateResponse reports how the Nodes were created in the system.
 8472    '''
 8473    __slots__ = [
 8474        'meta',
 8475        'node',
 8476        'rate_limit',
 8477        'token',
 8478    ]
 8479
 8480    def __init__(
 8481        self,
 8482        meta=None,
 8483        node=None,
 8484        rate_limit=None,
 8485        token=None,
 8486    ):
 8487        self.meta = meta if meta is not None else None
 8488        '''
 8489         Reserved for future use.
 8490        '''
 8491        self.node = node if node is not None else None
 8492        '''
 8493         The created Node.
 8494        '''
 8495        self.rate_limit = rate_limit if rate_limit is not None else None
 8496        '''
 8497         Rate limit information.
 8498        '''
 8499        self.token = token if token is not None else ''
 8500        '''
 8501         The auth token generated for the Node. The Node will use this token to
 8502         authenticate with the strongDM API.
 8503        '''
 8504
 8505    def __repr__(self):
 8506        return '<sdm.NodeCreateResponse ' + \
 8507            'meta: ' + repr(self.meta) + ' ' +\
 8508            'node: ' + repr(self.node) + ' ' +\
 8509            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8510            'token: ' + repr(self.token) + ' ' +\
 8511            '>'
 8512
 8513    def to_dict(self):
 8514        return {
 8515            'meta': self.meta,
 8516            'node': self.node,
 8517            'rate_limit': self.rate_limit,
 8518            'token': self.token,
 8519        }
 8520
 8521    @classmethod
 8522    def from_dict(cls, d):
 8523        return cls(
 8524            meta=d.get('meta'),
 8525            node=d.get('node'),
 8526            rate_limit=d.get('rate_limit'),
 8527            token=d.get('token'),
 8528        )
 8529
 8530
 8531class NodeDeleteResponse:
 8532    '''
 8533         NodeDeleteResponse returns information about a Node that was deleted.
 8534    '''
 8535    __slots__ = [
 8536        'meta',
 8537        'rate_limit',
 8538    ]
 8539
 8540    def __init__(
 8541        self,
 8542        meta=None,
 8543        rate_limit=None,
 8544    ):
 8545        self.meta = meta if meta is not None else None
 8546        '''
 8547         Reserved for future use.
 8548        '''
 8549        self.rate_limit = rate_limit if rate_limit is not None else None
 8550        '''
 8551         Rate limit information.
 8552        '''
 8553
 8554    def __repr__(self):
 8555        return '<sdm.NodeDeleteResponse ' + \
 8556            'meta: ' + repr(self.meta) + ' ' +\
 8557            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8558            '>'
 8559
 8560    def to_dict(self):
 8561        return {
 8562            'meta': self.meta,
 8563            'rate_limit': self.rate_limit,
 8564        }
 8565
 8566    @classmethod
 8567    def from_dict(cls, d):
 8568        return cls(
 8569            meta=d.get('meta'),
 8570            rate_limit=d.get('rate_limit'),
 8571        )
 8572
 8573
 8574class NodeGetResponse:
 8575    '''
 8576         NodeGetResponse returns a requested Node.
 8577    '''
 8578    __slots__ = [
 8579        'meta',
 8580        'node',
 8581        'rate_limit',
 8582    ]
 8583
 8584    def __init__(
 8585        self,
 8586        meta=None,
 8587        node=None,
 8588        rate_limit=None,
 8589    ):
 8590        self.meta = meta if meta is not None else None
 8591        '''
 8592         Reserved for future use.
 8593        '''
 8594        self.node = node if node is not None else None
 8595        '''
 8596         The requested Node.
 8597        '''
 8598        self.rate_limit = rate_limit if rate_limit is not None else None
 8599        '''
 8600         Rate limit information.
 8601        '''
 8602
 8603    def __repr__(self):
 8604        return '<sdm.NodeGetResponse ' + \
 8605            'meta: ' + repr(self.meta) + ' ' +\
 8606            'node: ' + repr(self.node) + ' ' +\
 8607            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8608            '>'
 8609
 8610    def to_dict(self):
 8611        return {
 8612            'meta': self.meta,
 8613            'node': self.node,
 8614            'rate_limit': self.rate_limit,
 8615        }
 8616
 8617    @classmethod
 8618    def from_dict(cls, d):
 8619        return cls(
 8620            meta=d.get('meta'),
 8621            node=d.get('node'),
 8622            rate_limit=d.get('rate_limit'),
 8623        )
 8624
 8625
 8626class NodeUpdateResponse:
 8627    '''
 8628         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8629     a NodeUpdateRequest.
 8630    '''
 8631    __slots__ = [
 8632        'meta',
 8633        'node',
 8634        'rate_limit',
 8635    ]
 8636
 8637    def __init__(
 8638        self,
 8639        meta=None,
 8640        node=None,
 8641        rate_limit=None,
 8642    ):
 8643        self.meta = meta if meta is not None else None
 8644        '''
 8645         Reserved for future use.
 8646        '''
 8647        self.node = node if node is not None else None
 8648        '''
 8649         The updated Node.
 8650        '''
 8651        self.rate_limit = rate_limit if rate_limit is not None else None
 8652        '''
 8653         Rate limit information.
 8654        '''
 8655
 8656    def __repr__(self):
 8657        return '<sdm.NodeUpdateResponse ' + \
 8658            'meta: ' + repr(self.meta) + ' ' +\
 8659            'node: ' + repr(self.node) + ' ' +\
 8660            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8661            '>'
 8662
 8663    def to_dict(self):
 8664        return {
 8665            'meta': self.meta,
 8666            'node': self.node,
 8667            'rate_limit': self.rate_limit,
 8668        }
 8669
 8670    @classmethod
 8671    def from_dict(cls, d):
 8672        return cls(
 8673            meta=d.get('meta'),
 8674            node=d.get('node'),
 8675            rate_limit=d.get('rate_limit'),
 8676        )
 8677
 8678
 8679class Oracle:
 8680    __slots__ = [
 8681        'bind_interface',
 8682        'database',
 8683        'egress_filter',
 8684        'healthy',
 8685        'hostname',
 8686        'id',
 8687        'name',
 8688        'password',
 8689        'port',
 8690        'port_override',
 8691        'secret_store_id',
 8692        'tags',
 8693        'tls_required',
 8694        'username',
 8695    ]
 8696
 8697    def __init__(
 8698        self,
 8699        bind_interface=None,
 8700        database=None,
 8701        egress_filter=None,
 8702        healthy=None,
 8703        hostname=None,
 8704        id=None,
 8705        name=None,
 8706        password=None,
 8707        port=None,
 8708        port_override=None,
 8709        secret_store_id=None,
 8710        tags=None,
 8711        tls_required=None,
 8712        username=None,
 8713    ):
 8714        self.bind_interface = bind_interface if bind_interface is not None else ''
 8715        '''
 8716         Bind interface
 8717        '''
 8718        self.database = database if database is not None else ''
 8719        self.egress_filter = egress_filter if egress_filter is not None else ''
 8720        '''
 8721         A filter applied to the routing logic to pin datasource to nodes.
 8722        '''
 8723        self.healthy = healthy if healthy is not None else False
 8724        '''
 8725         True if the datasource is reachable and the credentials are valid.
 8726        '''
 8727        self.hostname = hostname if hostname is not None else ''
 8728        self.id = id if id is not None else ''
 8729        '''
 8730         Unique identifier of the Resource.
 8731        '''
 8732        self.name = name if name is not None else ''
 8733        '''
 8734         Unique human-readable name of the Resource.
 8735        '''
 8736        self.password = password if password is not None else ''
 8737        self.port = port if port is not None else 0
 8738        self.port_override = port_override if port_override is not None else 0
 8739        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8740        '''
 8741         ID of the secret store containing credentials for this resource, if any.
 8742        '''
 8743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8744        '''
 8745         Tags is a map of key, value pairs.
 8746        '''
 8747        self.tls_required = tls_required if tls_required is not None else False
 8748        self.username = username if username is not None else ''
 8749
 8750    def __repr__(self):
 8751        return '<sdm.Oracle ' + \
 8752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8753            'database: ' + repr(self.database) + ' ' +\
 8754            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8755            'healthy: ' + repr(self.healthy) + ' ' +\
 8756            'hostname: ' + repr(self.hostname) + ' ' +\
 8757            'id: ' + repr(self.id) + ' ' +\
 8758            'name: ' + repr(self.name) + ' ' +\
 8759            'password: ' + repr(self.password) + ' ' +\
 8760            'port: ' + repr(self.port) + ' ' +\
 8761            'port_override: ' + repr(self.port_override) + ' ' +\
 8762            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8763            'tags: ' + repr(self.tags) + ' ' +\
 8764            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8765            'username: ' + repr(self.username) + ' ' +\
 8766            '>'
 8767
 8768    def to_dict(self):
 8769        return {
 8770            'bind_interface': self.bind_interface,
 8771            'database': self.database,
 8772            'egress_filter': self.egress_filter,
 8773            'healthy': self.healthy,
 8774            'hostname': self.hostname,
 8775            'id': self.id,
 8776            'name': self.name,
 8777            'password': self.password,
 8778            'port': self.port,
 8779            'port_override': self.port_override,
 8780            'secret_store_id': self.secret_store_id,
 8781            'tags': self.tags,
 8782            'tls_required': self.tls_required,
 8783            'username': self.username,
 8784        }
 8785
 8786    @classmethod
 8787    def from_dict(cls, d):
 8788        return cls(
 8789            bind_interface=d.get('bind_interface'),
 8790            database=d.get('database'),
 8791            egress_filter=d.get('egress_filter'),
 8792            healthy=d.get('healthy'),
 8793            hostname=d.get('hostname'),
 8794            id=d.get('id'),
 8795            name=d.get('name'),
 8796            password=d.get('password'),
 8797            port=d.get('port'),
 8798            port_override=d.get('port_override'),
 8799            secret_store_id=d.get('secret_store_id'),
 8800            tags=d.get('tags'),
 8801            tls_required=d.get('tls_required'),
 8802            username=d.get('username'),
 8803        )
 8804
 8805
 8806class Postgres:
 8807    __slots__ = [
 8808        'bind_interface',
 8809        'database',
 8810        'egress_filter',
 8811        'healthy',
 8812        'hostname',
 8813        'id',
 8814        'name',
 8815        'override_database',
 8816        'password',
 8817        'port',
 8818        'port_override',
 8819        'secret_store_id',
 8820        'tags',
 8821        'username',
 8822    ]
 8823
 8824    def __init__(
 8825        self,
 8826        bind_interface=None,
 8827        database=None,
 8828        egress_filter=None,
 8829        healthy=None,
 8830        hostname=None,
 8831        id=None,
 8832        name=None,
 8833        override_database=None,
 8834        password=None,
 8835        port=None,
 8836        port_override=None,
 8837        secret_store_id=None,
 8838        tags=None,
 8839        username=None,
 8840    ):
 8841        self.bind_interface = bind_interface if bind_interface is not None else ''
 8842        '''
 8843         Bind interface
 8844        '''
 8845        self.database = database if database is not None else ''
 8846        self.egress_filter = egress_filter if egress_filter is not None else ''
 8847        '''
 8848         A filter applied to the routing logic to pin datasource to nodes.
 8849        '''
 8850        self.healthy = healthy if healthy is not None else False
 8851        '''
 8852         True if the datasource is reachable and the credentials are valid.
 8853        '''
 8854        self.hostname = hostname if hostname is not None else ''
 8855        self.id = id if id is not None else ''
 8856        '''
 8857         Unique identifier of the Resource.
 8858        '''
 8859        self.name = name if name is not None else ''
 8860        '''
 8861         Unique human-readable name of the Resource.
 8862        '''
 8863        self.override_database = override_database if override_database is not None else False
 8864        self.password = password if password is not None else ''
 8865        self.port = port if port is not None else 0
 8866        self.port_override = port_override if port_override is not None else 0
 8867        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8868        '''
 8869         ID of the secret store containing credentials for this resource, if any.
 8870        '''
 8871        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8872        '''
 8873         Tags is a map of key, value pairs.
 8874        '''
 8875        self.username = username if username is not None else ''
 8876
 8877    def __repr__(self):
 8878        return '<sdm.Postgres ' + \
 8879            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8880            'database: ' + repr(self.database) + ' ' +\
 8881            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8882            'healthy: ' + repr(self.healthy) + ' ' +\
 8883            'hostname: ' + repr(self.hostname) + ' ' +\
 8884            'id: ' + repr(self.id) + ' ' +\
 8885            'name: ' + repr(self.name) + ' ' +\
 8886            'override_database: ' + repr(self.override_database) + ' ' +\
 8887            'password: ' + repr(self.password) + ' ' +\
 8888            'port: ' + repr(self.port) + ' ' +\
 8889            'port_override: ' + repr(self.port_override) + ' ' +\
 8890            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8891            'tags: ' + repr(self.tags) + ' ' +\
 8892            'username: ' + repr(self.username) + ' ' +\
 8893            '>'
 8894
 8895    def to_dict(self):
 8896        return {
 8897            'bind_interface': self.bind_interface,
 8898            'database': self.database,
 8899            'egress_filter': self.egress_filter,
 8900            'healthy': self.healthy,
 8901            'hostname': self.hostname,
 8902            'id': self.id,
 8903            'name': self.name,
 8904            'override_database': self.override_database,
 8905            'password': self.password,
 8906            'port': self.port,
 8907            'port_override': self.port_override,
 8908            'secret_store_id': self.secret_store_id,
 8909            'tags': self.tags,
 8910            'username': self.username,
 8911        }
 8912
 8913    @classmethod
 8914    def from_dict(cls, d):
 8915        return cls(
 8916            bind_interface=d.get('bind_interface'),
 8917            database=d.get('database'),
 8918            egress_filter=d.get('egress_filter'),
 8919            healthy=d.get('healthy'),
 8920            hostname=d.get('hostname'),
 8921            id=d.get('id'),
 8922            name=d.get('name'),
 8923            override_database=d.get('override_database'),
 8924            password=d.get('password'),
 8925            port=d.get('port'),
 8926            port_override=d.get('port_override'),
 8927            secret_store_id=d.get('secret_store_id'),
 8928            tags=d.get('tags'),
 8929            username=d.get('username'),
 8930        )
 8931
 8932
 8933class Presto:
 8934    __slots__ = [
 8935        'bind_interface',
 8936        'database',
 8937        'egress_filter',
 8938        'healthy',
 8939        'hostname',
 8940        'id',
 8941        'name',
 8942        'password',
 8943        'port',
 8944        'port_override',
 8945        'secret_store_id',
 8946        'tags',
 8947        'tls_required',
 8948        'username',
 8949    ]
 8950
 8951    def __init__(
 8952        self,
 8953        bind_interface=None,
 8954        database=None,
 8955        egress_filter=None,
 8956        healthy=None,
 8957        hostname=None,
 8958        id=None,
 8959        name=None,
 8960        password=None,
 8961        port=None,
 8962        port_override=None,
 8963        secret_store_id=None,
 8964        tags=None,
 8965        tls_required=None,
 8966        username=None,
 8967    ):
 8968        self.bind_interface = bind_interface if bind_interface is not None else ''
 8969        '''
 8970         Bind interface
 8971        '''
 8972        self.database = database if database is not None else ''
 8973        self.egress_filter = egress_filter if egress_filter is not None else ''
 8974        '''
 8975         A filter applied to the routing logic to pin datasource to nodes.
 8976        '''
 8977        self.healthy = healthy if healthy is not None else False
 8978        '''
 8979         True if the datasource is reachable and the credentials are valid.
 8980        '''
 8981        self.hostname = hostname if hostname is not None else ''
 8982        self.id = id if id is not None else ''
 8983        '''
 8984         Unique identifier of the Resource.
 8985        '''
 8986        self.name = name if name is not None else ''
 8987        '''
 8988         Unique human-readable name of the Resource.
 8989        '''
 8990        self.password = password if password is not None else ''
 8991        self.port = port if port is not None else 0
 8992        self.port_override = port_override if port_override is not None else 0
 8993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8994        '''
 8995         ID of the secret store containing credentials for this resource, if any.
 8996        '''
 8997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8998        '''
 8999         Tags is a map of key, value pairs.
 9000        '''
 9001        self.tls_required = tls_required if tls_required is not None else False
 9002        self.username = username if username is not None else ''
 9003
 9004    def __repr__(self):
 9005        return '<sdm.Presto ' + \
 9006            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9007            'database: ' + repr(self.database) + ' ' +\
 9008            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9009            'healthy: ' + repr(self.healthy) + ' ' +\
 9010            'hostname: ' + repr(self.hostname) + ' ' +\
 9011            'id: ' + repr(self.id) + ' ' +\
 9012            'name: ' + repr(self.name) + ' ' +\
 9013            'password: ' + repr(self.password) + ' ' +\
 9014            'port: ' + repr(self.port) + ' ' +\
 9015            'port_override: ' + repr(self.port_override) + ' ' +\
 9016            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9017            'tags: ' + repr(self.tags) + ' ' +\
 9018            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9019            'username: ' + repr(self.username) + ' ' +\
 9020            '>'
 9021
 9022    def to_dict(self):
 9023        return {
 9024            'bind_interface': self.bind_interface,
 9025            'database': self.database,
 9026            'egress_filter': self.egress_filter,
 9027            'healthy': self.healthy,
 9028            'hostname': self.hostname,
 9029            'id': self.id,
 9030            'name': self.name,
 9031            'password': self.password,
 9032            'port': self.port,
 9033            'port_override': self.port_override,
 9034            'secret_store_id': self.secret_store_id,
 9035            'tags': self.tags,
 9036            'tls_required': self.tls_required,
 9037            'username': self.username,
 9038        }
 9039
 9040    @classmethod
 9041    def from_dict(cls, d):
 9042        return cls(
 9043            bind_interface=d.get('bind_interface'),
 9044            database=d.get('database'),
 9045            egress_filter=d.get('egress_filter'),
 9046            healthy=d.get('healthy'),
 9047            hostname=d.get('hostname'),
 9048            id=d.get('id'),
 9049            name=d.get('name'),
 9050            password=d.get('password'),
 9051            port=d.get('port'),
 9052            port_override=d.get('port_override'),
 9053            secret_store_id=d.get('secret_store_id'),
 9054            tags=d.get('tags'),
 9055            tls_required=d.get('tls_required'),
 9056            username=d.get('username'),
 9057        )
 9058
 9059
 9060class RDP:
 9061    __slots__ = [
 9062        'bind_interface',
 9063        'downgrade_nla_connections',
 9064        'egress_filter',
 9065        'healthy',
 9066        'hostname',
 9067        'id',
 9068        'name',
 9069        'password',
 9070        'port',
 9071        'port_override',
 9072        'secret_store_id',
 9073        'tags',
 9074        'username',
 9075    ]
 9076
 9077    def __init__(
 9078        self,
 9079        bind_interface=None,
 9080        downgrade_nla_connections=None,
 9081        egress_filter=None,
 9082        healthy=None,
 9083        hostname=None,
 9084        id=None,
 9085        name=None,
 9086        password=None,
 9087        port=None,
 9088        port_override=None,
 9089        secret_store_id=None,
 9090        tags=None,
 9091        username=None,
 9092    ):
 9093        self.bind_interface = bind_interface if bind_interface is not None else ''
 9094        '''
 9095         Bind interface
 9096        '''
 9097        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9098        self.egress_filter = egress_filter if egress_filter is not None else ''
 9099        '''
 9100         A filter applied to the routing logic to pin datasource to nodes.
 9101        '''
 9102        self.healthy = healthy if healthy is not None else False
 9103        '''
 9104         True if the datasource is reachable and the credentials are valid.
 9105        '''
 9106        self.hostname = hostname if hostname is not None else ''
 9107        self.id = id if id is not None else ''
 9108        '''
 9109         Unique identifier of the Resource.
 9110        '''
 9111        self.name = name if name is not None else ''
 9112        '''
 9113         Unique human-readable name of the Resource.
 9114        '''
 9115        self.password = password if password is not None else ''
 9116        self.port = port if port is not None else 0
 9117        self.port_override = port_override if port_override is not None else 0
 9118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9119        '''
 9120         ID of the secret store containing credentials for this resource, if any.
 9121        '''
 9122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9123        '''
 9124         Tags is a map of key, value pairs.
 9125        '''
 9126        self.username = username if username is not None else ''
 9127
 9128    def __repr__(self):
 9129        return '<sdm.RDP ' + \
 9130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9131            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9132            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9133            'healthy: ' + repr(self.healthy) + ' ' +\
 9134            'hostname: ' + repr(self.hostname) + ' ' +\
 9135            'id: ' + repr(self.id) + ' ' +\
 9136            'name: ' + repr(self.name) + ' ' +\
 9137            'password: ' + repr(self.password) + ' ' +\
 9138            'port: ' + repr(self.port) + ' ' +\
 9139            'port_override: ' + repr(self.port_override) + ' ' +\
 9140            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9141            'tags: ' + repr(self.tags) + ' ' +\
 9142            'username: ' + repr(self.username) + ' ' +\
 9143            '>'
 9144
 9145    def to_dict(self):
 9146        return {
 9147            'bind_interface': self.bind_interface,
 9148            'downgrade_nla_connections': self.downgrade_nla_connections,
 9149            'egress_filter': self.egress_filter,
 9150            'healthy': self.healthy,
 9151            'hostname': self.hostname,
 9152            'id': self.id,
 9153            'name': self.name,
 9154            'password': self.password,
 9155            'port': self.port,
 9156            'port_override': self.port_override,
 9157            'secret_store_id': self.secret_store_id,
 9158            'tags': self.tags,
 9159            'username': self.username,
 9160        }
 9161
 9162    @classmethod
 9163    def from_dict(cls, d):
 9164        return cls(
 9165            bind_interface=d.get('bind_interface'),
 9166            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9167            egress_filter=d.get('egress_filter'),
 9168            healthy=d.get('healthy'),
 9169            hostname=d.get('hostname'),
 9170            id=d.get('id'),
 9171            name=d.get('name'),
 9172            password=d.get('password'),
 9173            port=d.get('port'),
 9174            port_override=d.get('port_override'),
 9175            secret_store_id=d.get('secret_store_id'),
 9176            tags=d.get('tags'),
 9177            username=d.get('username'),
 9178        )
 9179
 9180
 9181class RabbitMQAMQP091:
 9182    __slots__ = [
 9183        'bind_interface',
 9184        'egress_filter',
 9185        'healthy',
 9186        'hostname',
 9187        'id',
 9188        'name',
 9189        'password',
 9190        'port',
 9191        'port_override',
 9192        'secret_store_id',
 9193        'tags',
 9194        'tls_required',
 9195        'username',
 9196    ]
 9197
 9198    def __init__(
 9199        self,
 9200        bind_interface=None,
 9201        egress_filter=None,
 9202        healthy=None,
 9203        hostname=None,
 9204        id=None,
 9205        name=None,
 9206        password=None,
 9207        port=None,
 9208        port_override=None,
 9209        secret_store_id=None,
 9210        tags=None,
 9211        tls_required=None,
 9212        username=None,
 9213    ):
 9214        self.bind_interface = bind_interface if bind_interface is not None else ''
 9215        '''
 9216         Bind interface
 9217        '''
 9218        self.egress_filter = egress_filter if egress_filter is not None else ''
 9219        '''
 9220         A filter applied to the routing logic to pin datasource to nodes.
 9221        '''
 9222        self.healthy = healthy if healthy is not None else False
 9223        '''
 9224         True if the datasource is reachable and the credentials are valid.
 9225        '''
 9226        self.hostname = hostname if hostname is not None else ''
 9227        self.id = id if id is not None else ''
 9228        '''
 9229         Unique identifier of the Resource.
 9230        '''
 9231        self.name = name if name is not None else ''
 9232        '''
 9233         Unique human-readable name of the Resource.
 9234        '''
 9235        self.password = password if password is not None else ''
 9236        self.port = port if port is not None else 0
 9237        self.port_override = port_override if port_override is not None else 0
 9238        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9239        '''
 9240         ID of the secret store containing credentials for this resource, if any.
 9241        '''
 9242        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9243        '''
 9244         Tags is a map of key, value pairs.
 9245        '''
 9246        self.tls_required = tls_required if tls_required is not None else False
 9247        self.username = username if username is not None else ''
 9248
 9249    def __repr__(self):
 9250        return '<sdm.RabbitMQAMQP091 ' + \
 9251            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9252            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9253            'healthy: ' + repr(self.healthy) + ' ' +\
 9254            'hostname: ' + repr(self.hostname) + ' ' +\
 9255            'id: ' + repr(self.id) + ' ' +\
 9256            'name: ' + repr(self.name) + ' ' +\
 9257            'password: ' + repr(self.password) + ' ' +\
 9258            'port: ' + repr(self.port) + ' ' +\
 9259            'port_override: ' + repr(self.port_override) + ' ' +\
 9260            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9261            'tags: ' + repr(self.tags) + ' ' +\
 9262            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9263            'username: ' + repr(self.username) + ' ' +\
 9264            '>'
 9265
 9266    def to_dict(self):
 9267        return {
 9268            'bind_interface': self.bind_interface,
 9269            'egress_filter': self.egress_filter,
 9270            'healthy': self.healthy,
 9271            'hostname': self.hostname,
 9272            'id': self.id,
 9273            'name': self.name,
 9274            'password': self.password,
 9275            'port': self.port,
 9276            'port_override': self.port_override,
 9277            'secret_store_id': self.secret_store_id,
 9278            'tags': self.tags,
 9279            'tls_required': self.tls_required,
 9280            'username': self.username,
 9281        }
 9282
 9283    @classmethod
 9284    def from_dict(cls, d):
 9285        return cls(
 9286            bind_interface=d.get('bind_interface'),
 9287            egress_filter=d.get('egress_filter'),
 9288            healthy=d.get('healthy'),
 9289            hostname=d.get('hostname'),
 9290            id=d.get('id'),
 9291            name=d.get('name'),
 9292            password=d.get('password'),
 9293            port=d.get('port'),
 9294            port_override=d.get('port_override'),
 9295            secret_store_id=d.get('secret_store_id'),
 9296            tags=d.get('tags'),
 9297            tls_required=d.get('tls_required'),
 9298            username=d.get('username'),
 9299        )
 9300
 9301
 9302class RateLimitMetadata:
 9303    '''
 9304         RateLimitMetadata contains information about remaining requests avaialable
 9305     to the user over some timeframe.
 9306    '''
 9307    __slots__ = [
 9308        'bucket',
 9309        'limit',
 9310        'remaining',
 9311        'reset_at',
 9312    ]
 9313
 9314    def __init__(
 9315        self,
 9316        bucket=None,
 9317        limit=None,
 9318        remaining=None,
 9319        reset_at=None,
 9320    ):
 9321        self.bucket = bucket if bucket is not None else ''
 9322        '''
 9323         The bucket this user/token is associated with, which may be shared between
 9324         multiple users/tokens.
 9325        '''
 9326        self.limit = limit if limit is not None else 0
 9327        '''
 9328         How many total requests the user/token is authorized to make before being
 9329         rate limited.
 9330        '''
 9331        self.remaining = remaining if remaining is not None else 0
 9332        '''
 9333         How many remaining requests out of the limit are still avaialable.
 9334        '''
 9335        self.reset_at = reset_at if reset_at is not None else None
 9336        '''
 9337         The time when remaining will be reset to limit.
 9338        '''
 9339
 9340    def __repr__(self):
 9341        return '<sdm.RateLimitMetadata ' + \
 9342            'bucket: ' + repr(self.bucket) + ' ' +\
 9343            'limit: ' + repr(self.limit) + ' ' +\
 9344            'remaining: ' + repr(self.remaining) + ' ' +\
 9345            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9346            '>'
 9347
 9348    def to_dict(self):
 9349        return {
 9350            'bucket': self.bucket,
 9351            'limit': self.limit,
 9352            'remaining': self.remaining,
 9353            'reset_at': self.reset_at,
 9354        }
 9355
 9356    @classmethod
 9357    def from_dict(cls, d):
 9358        return cls(
 9359            bucket=d.get('bucket'),
 9360            limit=d.get('limit'),
 9361            remaining=d.get('remaining'),
 9362            reset_at=d.get('reset_at'),
 9363        )
 9364
 9365
 9366class RawTCP:
 9367    __slots__ = [
 9368        'bind_interface',
 9369        'egress_filter',
 9370        'healthy',
 9371        'hostname',
 9372        'id',
 9373        'name',
 9374        'port',
 9375        'port_override',
 9376        'secret_store_id',
 9377        'tags',
 9378    ]
 9379
 9380    def __init__(
 9381        self,
 9382        bind_interface=None,
 9383        egress_filter=None,
 9384        healthy=None,
 9385        hostname=None,
 9386        id=None,
 9387        name=None,
 9388        port=None,
 9389        port_override=None,
 9390        secret_store_id=None,
 9391        tags=None,
 9392    ):
 9393        self.bind_interface = bind_interface if bind_interface is not None else ''
 9394        '''
 9395         Bind interface
 9396        '''
 9397        self.egress_filter = egress_filter if egress_filter is not None else ''
 9398        '''
 9399         A filter applied to the routing logic to pin datasource to nodes.
 9400        '''
 9401        self.healthy = healthy if healthy is not None else False
 9402        '''
 9403         True if the datasource is reachable and the credentials are valid.
 9404        '''
 9405        self.hostname = hostname if hostname is not None else ''
 9406        self.id = id if id is not None else ''
 9407        '''
 9408         Unique identifier of the Resource.
 9409        '''
 9410        self.name = name if name is not None else ''
 9411        '''
 9412         Unique human-readable name of the Resource.
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        self.port_override = port_override if port_override is not None else 0
 9416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9417        '''
 9418         ID of the secret store containing credentials for this resource, if any.
 9419        '''
 9420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9421        '''
 9422         Tags is a map of key, value pairs.
 9423        '''
 9424
 9425    def __repr__(self):
 9426        return '<sdm.RawTCP ' + \
 9427            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9428            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9429            'healthy: ' + repr(self.healthy) + ' ' +\
 9430            'hostname: ' + repr(self.hostname) + ' ' +\
 9431            'id: ' + repr(self.id) + ' ' +\
 9432            'name: ' + repr(self.name) + ' ' +\
 9433            'port: ' + repr(self.port) + ' ' +\
 9434            'port_override: ' + repr(self.port_override) + ' ' +\
 9435            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9436            'tags: ' + repr(self.tags) + ' ' +\
 9437            '>'
 9438
 9439    def to_dict(self):
 9440        return {
 9441            'bind_interface': self.bind_interface,
 9442            'egress_filter': self.egress_filter,
 9443            'healthy': self.healthy,
 9444            'hostname': self.hostname,
 9445            'id': self.id,
 9446            'name': self.name,
 9447            'port': self.port,
 9448            'port_override': self.port_override,
 9449            'secret_store_id': self.secret_store_id,
 9450            'tags': self.tags,
 9451        }
 9452
 9453    @classmethod
 9454    def from_dict(cls, d):
 9455        return cls(
 9456            bind_interface=d.get('bind_interface'),
 9457            egress_filter=d.get('egress_filter'),
 9458            healthy=d.get('healthy'),
 9459            hostname=d.get('hostname'),
 9460            id=d.get('id'),
 9461            name=d.get('name'),
 9462            port=d.get('port'),
 9463            port_override=d.get('port_override'),
 9464            secret_store_id=d.get('secret_store_id'),
 9465            tags=d.get('tags'),
 9466        )
 9467
 9468
 9469class Redis:
 9470    __slots__ = [
 9471        'bind_interface',
 9472        'egress_filter',
 9473        'healthy',
 9474        'hostname',
 9475        'id',
 9476        'name',
 9477        'password',
 9478        'port',
 9479        'port_override',
 9480        'secret_store_id',
 9481        'tags',
 9482    ]
 9483
 9484    def __init__(
 9485        self,
 9486        bind_interface=None,
 9487        egress_filter=None,
 9488        healthy=None,
 9489        hostname=None,
 9490        id=None,
 9491        name=None,
 9492        password=None,
 9493        port=None,
 9494        port_override=None,
 9495        secret_store_id=None,
 9496        tags=None,
 9497    ):
 9498        self.bind_interface = bind_interface if bind_interface is not None else ''
 9499        '''
 9500         Bind interface
 9501        '''
 9502        self.egress_filter = egress_filter if egress_filter is not None else ''
 9503        '''
 9504         A filter applied to the routing logic to pin datasource to nodes.
 9505        '''
 9506        self.healthy = healthy if healthy is not None else False
 9507        '''
 9508         True if the datasource is reachable and the credentials are valid.
 9509        '''
 9510        self.hostname = hostname if hostname is not None else ''
 9511        self.id = id if id is not None else ''
 9512        '''
 9513         Unique identifier of the Resource.
 9514        '''
 9515        self.name = name if name is not None else ''
 9516        '''
 9517         Unique human-readable name of the Resource.
 9518        '''
 9519        self.password = password if password is not None else ''
 9520        self.port = port if port is not None else 0
 9521        self.port_override = port_override if port_override is not None else 0
 9522        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9523        '''
 9524         ID of the secret store containing credentials for this resource, if any.
 9525        '''
 9526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9527        '''
 9528         Tags is a map of key, value pairs.
 9529        '''
 9530
 9531    def __repr__(self):
 9532        return '<sdm.Redis ' + \
 9533            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9534            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9535            'healthy: ' + repr(self.healthy) + ' ' +\
 9536            'hostname: ' + repr(self.hostname) + ' ' +\
 9537            'id: ' + repr(self.id) + ' ' +\
 9538            'name: ' + repr(self.name) + ' ' +\
 9539            'password: ' + repr(self.password) + ' ' +\
 9540            'port: ' + repr(self.port) + ' ' +\
 9541            'port_override: ' + repr(self.port_override) + ' ' +\
 9542            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9543            'tags: ' + repr(self.tags) + ' ' +\
 9544            '>'
 9545
 9546    def to_dict(self):
 9547        return {
 9548            'bind_interface': self.bind_interface,
 9549            'egress_filter': self.egress_filter,
 9550            'healthy': self.healthy,
 9551            'hostname': self.hostname,
 9552            'id': self.id,
 9553            'name': self.name,
 9554            'password': self.password,
 9555            'port': self.port,
 9556            'port_override': self.port_override,
 9557            'secret_store_id': self.secret_store_id,
 9558            'tags': self.tags,
 9559        }
 9560
 9561    @classmethod
 9562    def from_dict(cls, d):
 9563        return cls(
 9564            bind_interface=d.get('bind_interface'),
 9565            egress_filter=d.get('egress_filter'),
 9566            healthy=d.get('healthy'),
 9567            hostname=d.get('hostname'),
 9568            id=d.get('id'),
 9569            name=d.get('name'),
 9570            password=d.get('password'),
 9571            port=d.get('port'),
 9572            port_override=d.get('port_override'),
 9573            secret_store_id=d.get('secret_store_id'),
 9574            tags=d.get('tags'),
 9575        )
 9576
 9577
 9578class Redshift:
 9579    __slots__ = [
 9580        'bind_interface',
 9581        'database',
 9582        'egress_filter',
 9583        'healthy',
 9584        'hostname',
 9585        'id',
 9586        'name',
 9587        'override_database',
 9588        'password',
 9589        'port',
 9590        'port_override',
 9591        'secret_store_id',
 9592        'tags',
 9593        'username',
 9594    ]
 9595
 9596    def __init__(
 9597        self,
 9598        bind_interface=None,
 9599        database=None,
 9600        egress_filter=None,
 9601        healthy=None,
 9602        hostname=None,
 9603        id=None,
 9604        name=None,
 9605        override_database=None,
 9606        password=None,
 9607        port=None,
 9608        port_override=None,
 9609        secret_store_id=None,
 9610        tags=None,
 9611        username=None,
 9612    ):
 9613        self.bind_interface = bind_interface if bind_interface is not None else ''
 9614        '''
 9615         Bind interface
 9616        '''
 9617        self.database = database if database is not None else ''
 9618        self.egress_filter = egress_filter if egress_filter is not None else ''
 9619        '''
 9620         A filter applied to the routing logic to pin datasource to nodes.
 9621        '''
 9622        self.healthy = healthy if healthy is not None else False
 9623        '''
 9624         True if the datasource is reachable and the credentials are valid.
 9625        '''
 9626        self.hostname = hostname if hostname is not None else ''
 9627        self.id = id if id is not None else ''
 9628        '''
 9629         Unique identifier of the Resource.
 9630        '''
 9631        self.name = name if name is not None else ''
 9632        '''
 9633         Unique human-readable name of the Resource.
 9634        '''
 9635        self.override_database = override_database if override_database is not None else False
 9636        self.password = password if password is not None else ''
 9637        self.port = port if port is not None else 0
 9638        self.port_override = port_override if port_override is not None else 0
 9639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9640        '''
 9641         ID of the secret store containing credentials for this resource, if any.
 9642        '''
 9643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9644        '''
 9645         Tags is a map of key, value pairs.
 9646        '''
 9647        self.username = username if username is not None else ''
 9648
 9649    def __repr__(self):
 9650        return '<sdm.Redshift ' + \
 9651            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9652            'database: ' + repr(self.database) + ' ' +\
 9653            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9654            'healthy: ' + repr(self.healthy) + ' ' +\
 9655            'hostname: ' + repr(self.hostname) + ' ' +\
 9656            'id: ' + repr(self.id) + ' ' +\
 9657            'name: ' + repr(self.name) + ' ' +\
 9658            'override_database: ' + repr(self.override_database) + ' ' +\
 9659            'password: ' + repr(self.password) + ' ' +\
 9660            'port: ' + repr(self.port) + ' ' +\
 9661            'port_override: ' + repr(self.port_override) + ' ' +\
 9662            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9663            'tags: ' + repr(self.tags) + ' ' +\
 9664            'username: ' + repr(self.username) + ' ' +\
 9665            '>'
 9666
 9667    def to_dict(self):
 9668        return {
 9669            'bind_interface': self.bind_interface,
 9670            'database': self.database,
 9671            'egress_filter': self.egress_filter,
 9672            'healthy': self.healthy,
 9673            'hostname': self.hostname,
 9674            'id': self.id,
 9675            'name': self.name,
 9676            'override_database': self.override_database,
 9677            'password': self.password,
 9678            'port': self.port,
 9679            'port_override': self.port_override,
 9680            'secret_store_id': self.secret_store_id,
 9681            'tags': self.tags,
 9682            'username': self.username,
 9683        }
 9684
 9685    @classmethod
 9686    def from_dict(cls, d):
 9687        return cls(
 9688            bind_interface=d.get('bind_interface'),
 9689            database=d.get('database'),
 9690            egress_filter=d.get('egress_filter'),
 9691            healthy=d.get('healthy'),
 9692            hostname=d.get('hostname'),
 9693            id=d.get('id'),
 9694            name=d.get('name'),
 9695            override_database=d.get('override_database'),
 9696            password=d.get('password'),
 9697            port=d.get('port'),
 9698            port_override=d.get('port_override'),
 9699            secret_store_id=d.get('secret_store_id'),
 9700            tags=d.get('tags'),
 9701            username=d.get('username'),
 9702        )
 9703
 9704
 9705class Relay:
 9706    '''
 9707         Relay represents a StrongDM CLI installation running in relay mode.
 9708    '''
 9709    __slots__ = [
 9710        'device',
 9711        'gateway_filter',
 9712        'id',
 9713        'location',
 9714        'name',
 9715        'state',
 9716        'tags',
 9717        'version',
 9718    ]
 9719
 9720    def __init__(
 9721        self,
 9722        device=None,
 9723        gateway_filter=None,
 9724        id=None,
 9725        location=None,
 9726        name=None,
 9727        state=None,
 9728        tags=None,
 9729        version=None,
 9730    ):
 9731        self.device = device if device is not None else ''
 9732        '''
 9733         Device is a read only device name uploaded by the gateway process when 
 9734         it comes online.
 9735        '''
 9736        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9737        '''
 9738         GatewayFilter can be used to restrict the peering between relays and
 9739         gateways.
 9740        '''
 9741        self.id = id if id is not None else ''
 9742        '''
 9743         Unique identifier of the Relay.
 9744        '''
 9745        self.location = location if location is not None else ''
 9746        '''
 9747         Location is a read only network location uploaded by the gateway process
 9748         when it comes online.
 9749        '''
 9750        self.name = name if name is not None else ''
 9751        '''
 9752         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9753        '''
 9754        self.state = state if state is not None else ''
 9755        '''
 9756         The current state of the relay. One of: "new", "verifying_restart",
 9757         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9758         "unknown".
 9759        '''
 9760        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9761        '''
 9762         Tags is a map of key, value pairs.
 9763        '''
 9764        self.version = version if version is not None else ''
 9765        '''
 9766         Version is a read only sdm binary version uploaded by the gateway process
 9767         when it comes online.
 9768        '''
 9769
 9770    def __repr__(self):
 9771        return '<sdm.Relay ' + \
 9772            'device: ' + repr(self.device) + ' ' +\
 9773            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9774            'id: ' + repr(self.id) + ' ' +\
 9775            'location: ' + repr(self.location) + ' ' +\
 9776            'name: ' + repr(self.name) + ' ' +\
 9777            'state: ' + repr(self.state) + ' ' +\
 9778            'tags: ' + repr(self.tags) + ' ' +\
 9779            'version: ' + repr(self.version) + ' ' +\
 9780            '>'
 9781
 9782    def to_dict(self):
 9783        return {
 9784            'device': self.device,
 9785            'gateway_filter': self.gateway_filter,
 9786            'id': self.id,
 9787            'location': self.location,
 9788            'name': self.name,
 9789            'state': self.state,
 9790            'tags': self.tags,
 9791            'version': self.version,
 9792        }
 9793
 9794    @classmethod
 9795    def from_dict(cls, d):
 9796        return cls(
 9797            device=d.get('device'),
 9798            gateway_filter=d.get('gateway_filter'),
 9799            id=d.get('id'),
 9800            location=d.get('location'),
 9801            name=d.get('name'),
 9802            state=d.get('state'),
 9803            tags=d.get('tags'),
 9804            version=d.get('version'),
 9805        )
 9806
 9807
 9808class RemoteIdentity:
 9809    '''
 9810         RemoteIdentities define the username to be used for a specific account
 9811     when connecting to a remote resource using that group.
 9812    '''
 9813    __slots__ = [
 9814        'account_id',
 9815        'id',
 9816        'remote_identity_group_id',
 9817        'username',
 9818    ]
 9819
 9820    def __init__(
 9821        self,
 9822        account_id=None,
 9823        id=None,
 9824        remote_identity_group_id=None,
 9825        username=None,
 9826    ):
 9827        self.account_id = account_id if account_id is not None else ''
 9828        '''
 9829         The account for this remote identity.
 9830        '''
 9831        self.id = id if id is not None else ''
 9832        '''
 9833         Unique identifier of the RemoteIdentity.
 9834        '''
 9835        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9836        '''
 9837         The remote identity group.
 9838        '''
 9839        self.username = username if username is not None else ''
 9840        '''
 9841         The username to be used as the remote identity for this account.
 9842        '''
 9843
 9844    def __repr__(self):
 9845        return '<sdm.RemoteIdentity ' + \
 9846            'account_id: ' + repr(self.account_id) + ' ' +\
 9847            'id: ' + repr(self.id) + ' ' +\
 9848            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9849            'username: ' + repr(self.username) + ' ' +\
 9850            '>'
 9851
 9852    def to_dict(self):
 9853        return {
 9854            'account_id': self.account_id,
 9855            'id': self.id,
 9856            'remote_identity_group_id': self.remote_identity_group_id,
 9857            'username': self.username,
 9858        }
 9859
 9860    @classmethod
 9861    def from_dict(cls, d):
 9862        return cls(
 9863            account_id=d.get('account_id'),
 9864            id=d.get('id'),
 9865            remote_identity_group_id=d.get('remote_identity_group_id'),
 9866            username=d.get('username'),
 9867        )
 9868
 9869
 9870class RemoteIdentityCreateResponse:
 9871    '''
 9872         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9873    '''
 9874    __slots__ = [
 9875        'meta',
 9876        'rate_limit',
 9877        'remote_identity',
 9878    ]
 9879
 9880    def __init__(
 9881        self,
 9882        meta=None,
 9883        rate_limit=None,
 9884        remote_identity=None,
 9885    ):
 9886        self.meta = meta if meta is not None else None
 9887        '''
 9888         Reserved for future use.
 9889        '''
 9890        self.rate_limit = rate_limit if rate_limit is not None else None
 9891        '''
 9892         Rate limit information.
 9893        '''
 9894        self.remote_identity = remote_identity if remote_identity is not None else None
 9895        '''
 9896         The created RemoteIdentity.
 9897        '''
 9898
 9899    def __repr__(self):
 9900        return '<sdm.RemoteIdentityCreateResponse ' + \
 9901            'meta: ' + repr(self.meta) + ' ' +\
 9902            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9903            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9904            '>'
 9905
 9906    def to_dict(self):
 9907        return {
 9908            'meta': self.meta,
 9909            'rate_limit': self.rate_limit,
 9910            'remote_identity': self.remote_identity,
 9911        }
 9912
 9913    @classmethod
 9914    def from_dict(cls, d):
 9915        return cls(
 9916            meta=d.get('meta'),
 9917            rate_limit=d.get('rate_limit'),
 9918            remote_identity=d.get('remote_identity'),
 9919        )
 9920
 9921
 9922class RemoteIdentityDeleteResponse:
 9923    '''
 9924         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9925    '''
 9926    __slots__ = [
 9927        'meta',
 9928        'rate_limit',
 9929    ]
 9930
 9931    def __init__(
 9932        self,
 9933        meta=None,
 9934        rate_limit=None,
 9935    ):
 9936        self.meta = meta if meta is not None else None
 9937        '''
 9938         Reserved for future use.
 9939        '''
 9940        self.rate_limit = rate_limit if rate_limit is not None else None
 9941        '''
 9942         Rate limit information.
 9943        '''
 9944
 9945    def __repr__(self):
 9946        return '<sdm.RemoteIdentityDeleteResponse ' + \
 9947            'meta: ' + repr(self.meta) + ' ' +\
 9948            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9949            '>'
 9950
 9951    def to_dict(self):
 9952        return {
 9953            'meta': self.meta,
 9954            'rate_limit': self.rate_limit,
 9955        }
 9956
 9957    @classmethod
 9958    def from_dict(cls, d):
 9959        return cls(
 9960            meta=d.get('meta'),
 9961            rate_limit=d.get('rate_limit'),
 9962        )
 9963
 9964
 9965class RemoteIdentityGetResponse:
 9966    '''
 9967         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9968    '''
 9969    __slots__ = [
 9970        'meta',
 9971        'rate_limit',
 9972        'remote_identity',
 9973    ]
 9974
 9975    def __init__(
 9976        self,
 9977        meta=None,
 9978        rate_limit=None,
 9979        remote_identity=None,
 9980    ):
 9981        self.meta = meta if meta is not None else None
 9982        '''
 9983         Reserved for future use.
 9984        '''
 9985        self.rate_limit = rate_limit if rate_limit is not None else None
 9986        '''
 9987         Rate limit information.
 9988        '''
 9989        self.remote_identity = remote_identity if remote_identity is not None else None
 9990        '''
 9991         The requested RemoteIdentity.
 9992        '''
 9993
 9994    def __repr__(self):
 9995        return '<sdm.RemoteIdentityGetResponse ' + \
 9996            'meta: ' + repr(self.meta) + ' ' +\
 9997            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9998            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9999            '>'
10000
10001    def to_dict(self):
10002        return {
10003            'meta': self.meta,
10004            'rate_limit': self.rate_limit,
10005            'remote_identity': self.remote_identity,
10006        }
10007
10008    @classmethod
10009    def from_dict(cls, d):
10010        return cls(
10011            meta=d.get('meta'),
10012            rate_limit=d.get('rate_limit'),
10013            remote_identity=d.get('remote_identity'),
10014        )
10015
10016
10017class RemoteIdentityGroup:
10018    '''
10019         A RemoteIdentityGroup defines a group of remote identities.
10020    '''
10021    __slots__ = [
10022        'id',
10023        'name',
10024    ]
10025
10026    def __init__(
10027        self,
10028        id=None,
10029        name=None,
10030    ):
10031        self.id = id if id is not None else ''
10032        '''
10033         Unique identifier of the RemoteIdentityGroup.
10034        '''
10035        self.name = name if name is not None else ''
10036        '''
10037         Unique human-readable name of the RemoteIdentityGroup.
10038        '''
10039
10040    def __repr__(self):
10041        return '<sdm.RemoteIdentityGroup ' + \
10042            'id: ' + repr(self.id) + ' ' +\
10043            'name: ' + repr(self.name) + ' ' +\
10044            '>'
10045
10046    def to_dict(self):
10047        return {
10048            'id': self.id,
10049            'name': self.name,
10050        }
10051
10052    @classmethod
10053    def from_dict(cls, d):
10054        return cls(
10055            id=d.get('id'),
10056            name=d.get('name'),
10057        )
10058
10059
10060class RemoteIdentityGroupGetResponse:
10061    '''
10062         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10063    '''
10064    __slots__ = [
10065        'meta',
10066        'rate_limit',
10067        'remote_identity_group',
10068    ]
10069
10070    def __init__(
10071        self,
10072        meta=None,
10073        rate_limit=None,
10074        remote_identity_group=None,
10075    ):
10076        self.meta = meta if meta is not None else None
10077        '''
10078         Reserved for future use.
10079        '''
10080        self.rate_limit = rate_limit if rate_limit is not None else None
10081        '''
10082         Rate limit information.
10083        '''
10084        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10085        '''
10086         The requested RemoteIdentityGroup.
10087        '''
10088
10089    def __repr__(self):
10090        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10091            'meta: ' + repr(self.meta) + ' ' +\
10092            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10093            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10094            '>'
10095
10096    def to_dict(self):
10097        return {
10098            'meta': self.meta,
10099            'rate_limit': self.rate_limit,
10100            'remote_identity_group': self.remote_identity_group,
10101        }
10102
10103    @classmethod
10104    def from_dict(cls, d):
10105        return cls(
10106            meta=d.get('meta'),
10107            rate_limit=d.get('rate_limit'),
10108            remote_identity_group=d.get('remote_identity_group'),
10109        )
10110
10111
10112class RemoteIdentityUpdateResponse:
10113    '''
10114         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10115     a RemoteIdentityUpdateRequest.
10116    '''
10117    __slots__ = [
10118        'meta',
10119        'rate_limit',
10120        'remote_identity',
10121    ]
10122
10123    def __init__(
10124        self,
10125        meta=None,
10126        rate_limit=None,
10127        remote_identity=None,
10128    ):
10129        self.meta = meta if meta is not None else None
10130        '''
10131         Reserved for future use.
10132        '''
10133        self.rate_limit = rate_limit if rate_limit is not None else None
10134        '''
10135         Rate limit information.
10136        '''
10137        self.remote_identity = remote_identity if remote_identity is not None else None
10138        '''
10139         The updated RemoteIdentity.
10140        '''
10141
10142    def __repr__(self):
10143        return '<sdm.RemoteIdentityUpdateResponse ' + \
10144            'meta: ' + repr(self.meta) + ' ' +\
10145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10146            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10147            '>'
10148
10149    def to_dict(self):
10150        return {
10151            'meta': self.meta,
10152            'rate_limit': self.rate_limit,
10153            'remote_identity': self.remote_identity,
10154        }
10155
10156    @classmethod
10157    def from_dict(cls, d):
10158        return cls(
10159            meta=d.get('meta'),
10160            rate_limit=d.get('rate_limit'),
10161            remote_identity=d.get('remote_identity'),
10162        )
10163
10164
10165class ResourceCreateResponse:
10166    '''
10167         ResourceCreateResponse reports how the Resources were created in the system.
10168    '''
10169    __slots__ = [
10170        'meta',
10171        'rate_limit',
10172        'resource',
10173    ]
10174
10175    def __init__(
10176        self,
10177        meta=None,
10178        rate_limit=None,
10179        resource=None,
10180    ):
10181        self.meta = meta if meta is not None else None
10182        '''
10183         Reserved for future use.
10184        '''
10185        self.rate_limit = rate_limit if rate_limit is not None else None
10186        '''
10187         Rate limit information.
10188        '''
10189        self.resource = resource if resource is not None else None
10190        '''
10191         The created Resource.
10192        '''
10193
10194    def __repr__(self):
10195        return '<sdm.ResourceCreateResponse ' + \
10196            'meta: ' + repr(self.meta) + ' ' +\
10197            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10198            'resource: ' + repr(self.resource) + ' ' +\
10199            '>'
10200
10201    def to_dict(self):
10202        return {
10203            'meta': self.meta,
10204            'rate_limit': self.rate_limit,
10205            'resource': self.resource,
10206        }
10207
10208    @classmethod
10209    def from_dict(cls, d):
10210        return cls(
10211            meta=d.get('meta'),
10212            rate_limit=d.get('rate_limit'),
10213            resource=d.get('resource'),
10214        )
10215
10216
10217class ResourceDeleteResponse:
10218    '''
10219         ResourceDeleteResponse returns information about a Resource that was deleted.
10220    '''
10221    __slots__ = [
10222        'meta',
10223        'rate_limit',
10224    ]
10225
10226    def __init__(
10227        self,
10228        meta=None,
10229        rate_limit=None,
10230    ):
10231        self.meta = meta if meta is not None else None
10232        '''
10233         Reserved for future use.
10234        '''
10235        self.rate_limit = rate_limit if rate_limit is not None else None
10236        '''
10237         Rate limit information.
10238        '''
10239
10240    def __repr__(self):
10241        return '<sdm.ResourceDeleteResponse ' + \
10242            'meta: ' + repr(self.meta) + ' ' +\
10243            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10244            '>'
10245
10246    def to_dict(self):
10247        return {
10248            'meta': self.meta,
10249            'rate_limit': self.rate_limit,
10250        }
10251
10252    @classmethod
10253    def from_dict(cls, d):
10254        return cls(
10255            meta=d.get('meta'),
10256            rate_limit=d.get('rate_limit'),
10257        )
10258
10259
10260class ResourceGetResponse:
10261    '''
10262         ResourceGetResponse returns a requested Resource.
10263    '''
10264    __slots__ = [
10265        'meta',
10266        'rate_limit',
10267        'resource',
10268    ]
10269
10270    def __init__(
10271        self,
10272        meta=None,
10273        rate_limit=None,
10274        resource=None,
10275    ):
10276        self.meta = meta if meta is not None else None
10277        '''
10278         Reserved for future use.
10279        '''
10280        self.rate_limit = rate_limit if rate_limit is not None else None
10281        '''
10282         Rate limit information.
10283        '''
10284        self.resource = resource if resource is not None else None
10285        '''
10286         The requested Resource.
10287        '''
10288
10289    def __repr__(self):
10290        return '<sdm.ResourceGetResponse ' + \
10291            'meta: ' + repr(self.meta) + ' ' +\
10292            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10293            'resource: ' + repr(self.resource) + ' ' +\
10294            '>'
10295
10296    def to_dict(self):
10297        return {
10298            'meta': self.meta,
10299            'rate_limit': self.rate_limit,
10300            'resource': self.resource,
10301        }
10302
10303    @classmethod
10304    def from_dict(cls, d):
10305        return cls(
10306            meta=d.get('meta'),
10307            rate_limit=d.get('rate_limit'),
10308            resource=d.get('resource'),
10309        )
10310
10311
10312class ResourceUpdateResponse:
10313    '''
10314         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10315     a ResourceUpdateRequest.
10316    '''
10317    __slots__ = [
10318        'meta',
10319        'rate_limit',
10320        'resource',
10321    ]
10322
10323    def __init__(
10324        self,
10325        meta=None,
10326        rate_limit=None,
10327        resource=None,
10328    ):
10329        self.meta = meta if meta is not None else None
10330        '''
10331         Reserved for future use.
10332        '''
10333        self.rate_limit = rate_limit if rate_limit is not None else None
10334        '''
10335         Rate limit information.
10336        '''
10337        self.resource = resource if resource is not None else None
10338        '''
10339         The updated Resource.
10340        '''
10341
10342    def __repr__(self):
10343        return '<sdm.ResourceUpdateResponse ' + \
10344            'meta: ' + repr(self.meta) + ' ' +\
10345            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10346            'resource: ' + repr(self.resource) + ' ' +\
10347            '>'
10348
10349    def to_dict(self):
10350        return {
10351            'meta': self.meta,
10352            'rate_limit': self.rate_limit,
10353            'resource': self.resource,
10354        }
10355
10356    @classmethod
10357    def from_dict(cls, d):
10358        return cls(
10359            meta=d.get('meta'),
10360            rate_limit=d.get('rate_limit'),
10361            resource=d.get('resource'),
10362        )
10363
10364
10365class Role:
10366    '''
10367         A Role has a list of access rules which determine which Resources the members
10368     of the Role have access to. An Account can be a member of multiple Roles via
10369     AccountAttachments.
10370    '''
10371    __slots__ = [
10372        'access_rules',
10373        'id',
10374        'name',
10375        'tags',
10376    ]
10377
10378    def __init__(
10379        self,
10380        access_rules=None,
10381        id=None,
10382        name=None,
10383        tags=None,
10384    ):
10385        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10386        )
10387        '''
10388         AccessRules is a list of access rules defining the resources this Role has access to.
10389        '''
10390        self.id = id if id is not None else ''
10391        '''
10392         Unique identifier of the Role.
10393        '''
10394        self.name = name if name is not None else ''
10395        '''
10396         Unique human-readable name of the Role.
10397        '''
10398        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10399        '''
10400         Tags is a map of key, value pairs.
10401        '''
10402
10403    def __repr__(self):
10404        return '<sdm.Role ' + \
10405            'access_rules: ' + repr(self.access_rules) + ' ' +\
10406            'id: ' + repr(self.id) + ' ' +\
10407            'name: ' + repr(self.name) + ' ' +\
10408            'tags: ' + repr(self.tags) + ' ' +\
10409            '>'
10410
10411    def to_dict(self):
10412        return {
10413            'access_rules': self.access_rules,
10414            'id': self.id,
10415            'name': self.name,
10416            'tags': self.tags,
10417        }
10418
10419    @classmethod
10420    def from_dict(cls, d):
10421        return cls(
10422            access_rules=d.get('access_rules'),
10423            id=d.get('id'),
10424            name=d.get('name'),
10425            tags=d.get('tags'),
10426        )
10427
10428
10429class RoleCreateResponse:
10430    '''
10431         RoleCreateResponse reports how the Roles were created in the system. It can
10432     communicate partial successes or failures.
10433    '''
10434    __slots__ = [
10435        'meta',
10436        'rate_limit',
10437        'role',
10438    ]
10439
10440    def __init__(
10441        self,
10442        meta=None,
10443        rate_limit=None,
10444        role=None,
10445    ):
10446        self.meta = meta if meta is not None else None
10447        '''
10448         Reserved for future use.
10449        '''
10450        self.rate_limit = rate_limit if rate_limit is not None else None
10451        '''
10452         Rate limit information.
10453        '''
10454        self.role = role if role is not None else None
10455        '''
10456         The created Role.
10457        '''
10458
10459    def __repr__(self):
10460        return '<sdm.RoleCreateResponse ' + \
10461            'meta: ' + repr(self.meta) + ' ' +\
10462            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10463            'role: ' + repr(self.role) + ' ' +\
10464            '>'
10465
10466    def to_dict(self):
10467        return {
10468            'meta': self.meta,
10469            'rate_limit': self.rate_limit,
10470            'role': self.role,
10471        }
10472
10473    @classmethod
10474    def from_dict(cls, d):
10475        return cls(
10476            meta=d.get('meta'),
10477            rate_limit=d.get('rate_limit'),
10478            role=d.get('role'),
10479        )
10480
10481
10482class RoleDeleteResponse:
10483    '''
10484         RoleDeleteResponse returns information about a Role that was deleted.
10485    '''
10486    __slots__ = [
10487        'meta',
10488        'rate_limit',
10489    ]
10490
10491    def __init__(
10492        self,
10493        meta=None,
10494        rate_limit=None,
10495    ):
10496        self.meta = meta if meta is not None else None
10497        '''
10498         Reserved for future use.
10499        '''
10500        self.rate_limit = rate_limit if rate_limit is not None else None
10501        '''
10502         Rate limit information.
10503        '''
10504
10505    def __repr__(self):
10506        return '<sdm.RoleDeleteResponse ' + \
10507            'meta: ' + repr(self.meta) + ' ' +\
10508            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10509            '>'
10510
10511    def to_dict(self):
10512        return {
10513            'meta': self.meta,
10514            'rate_limit': self.rate_limit,
10515        }
10516
10517    @classmethod
10518    def from_dict(cls, d):
10519        return cls(
10520            meta=d.get('meta'),
10521            rate_limit=d.get('rate_limit'),
10522        )
10523
10524
10525class RoleGetResponse:
10526    '''
10527         RoleGetResponse returns a requested Role.
10528    '''
10529    __slots__ = [
10530        'meta',
10531        'rate_limit',
10532        'role',
10533    ]
10534
10535    def __init__(
10536        self,
10537        meta=None,
10538        rate_limit=None,
10539        role=None,
10540    ):
10541        self.meta = meta if meta is not None else None
10542        '''
10543         Reserved for future use.
10544        '''
10545        self.rate_limit = rate_limit if rate_limit is not None else None
10546        '''
10547         Rate limit information.
10548        '''
10549        self.role = role if role is not None else None
10550        '''
10551         The requested Role.
10552        '''
10553
10554    def __repr__(self):
10555        return '<sdm.RoleGetResponse ' + \
10556            'meta: ' + repr(self.meta) + ' ' +\
10557            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10558            'role: ' + repr(self.role) + ' ' +\
10559            '>'
10560
10561    def to_dict(self):
10562        return {
10563            'meta': self.meta,
10564            'rate_limit': self.rate_limit,
10565            'role': self.role,
10566        }
10567
10568    @classmethod
10569    def from_dict(cls, d):
10570        return cls(
10571            meta=d.get('meta'),
10572            rate_limit=d.get('rate_limit'),
10573            role=d.get('role'),
10574        )
10575
10576
10577class RoleUpdateResponse:
10578    '''
10579         RoleUpdateResponse returns the fields of a Role after it has been updated by
10580     a RoleUpdateRequest.
10581    '''
10582    __slots__ = [
10583        'meta',
10584        'rate_limit',
10585        'role',
10586    ]
10587
10588    def __init__(
10589        self,
10590        meta=None,
10591        rate_limit=None,
10592        role=None,
10593    ):
10594        self.meta = meta if meta is not None else None
10595        '''
10596         Reserved for future use.
10597        '''
10598        self.rate_limit = rate_limit if rate_limit is not None else None
10599        '''
10600         Rate limit information.
10601        '''
10602        self.role = role if role is not None else None
10603        '''
10604         The updated Role.
10605        '''
10606
10607    def __repr__(self):
10608        return '<sdm.RoleUpdateResponse ' + \
10609            'meta: ' + repr(self.meta) + ' ' +\
10610            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10611            'role: ' + repr(self.role) + ' ' +\
10612            '>'
10613
10614    def to_dict(self):
10615        return {
10616            'meta': self.meta,
10617            'rate_limit': self.rate_limit,
10618            'role': self.role,
10619        }
10620
10621    @classmethod
10622    def from_dict(cls, d):
10623        return cls(
10624            meta=d.get('meta'),
10625            rate_limit=d.get('rate_limit'),
10626            role=d.get('role'),
10627        )
10628
10629
10630class SQLServer:
10631    __slots__ = [
10632        'bind_interface',
10633        'database',
10634        'egress_filter',
10635        'healthy',
10636        'hostname',
10637        'id',
10638        'name',
10639        'override_database',
10640        'password',
10641        'port',
10642        'port_override',
10643        'schema',
10644        'secret_store_id',
10645        'tags',
10646        'username',
10647    ]
10648
10649    def __init__(
10650        self,
10651        bind_interface=None,
10652        database=None,
10653        egress_filter=None,
10654        healthy=None,
10655        hostname=None,
10656        id=None,
10657        name=None,
10658        override_database=None,
10659        password=None,
10660        port=None,
10661        port_override=None,
10662        schema=None,
10663        secret_store_id=None,
10664        tags=None,
10665        username=None,
10666    ):
10667        self.bind_interface = bind_interface if bind_interface is not None else ''
10668        '''
10669         Bind interface
10670        '''
10671        self.database = database if database is not None else ''
10672        self.egress_filter = egress_filter if egress_filter is not None else ''
10673        '''
10674         A filter applied to the routing logic to pin datasource to nodes.
10675        '''
10676        self.healthy = healthy if healthy is not None else False
10677        '''
10678         True if the datasource is reachable and the credentials are valid.
10679        '''
10680        self.hostname = hostname if hostname is not None else ''
10681        self.id = id if id is not None else ''
10682        '''
10683         Unique identifier of the Resource.
10684        '''
10685        self.name = name if name is not None else ''
10686        '''
10687         Unique human-readable name of the Resource.
10688        '''
10689        self.override_database = override_database if override_database is not None else False
10690        self.password = password if password is not None else ''
10691        self.port = port if port is not None else 0
10692        self.port_override = port_override if port_override is not None else 0
10693        self.schema = schema if schema is not None else ''
10694        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10695        '''
10696         ID of the secret store containing credentials for this resource, if any.
10697        '''
10698        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10699        '''
10700         Tags is a map of key, value pairs.
10701        '''
10702        self.username = username if username is not None else ''
10703
10704    def __repr__(self):
10705        return '<sdm.SQLServer ' + \
10706            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10707            'database: ' + repr(self.database) + ' ' +\
10708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10709            'healthy: ' + repr(self.healthy) + ' ' +\
10710            'hostname: ' + repr(self.hostname) + ' ' +\
10711            'id: ' + repr(self.id) + ' ' +\
10712            'name: ' + repr(self.name) + ' ' +\
10713            'override_database: ' + repr(self.override_database) + ' ' +\
10714            'password: ' + repr(self.password) + ' ' +\
10715            'port: ' + repr(self.port) + ' ' +\
10716            'port_override: ' + repr(self.port_override) + ' ' +\
10717            'schema: ' + repr(self.schema) + ' ' +\
10718            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10719            'tags: ' + repr(self.tags) + ' ' +\
10720            'username: ' + repr(self.username) + ' ' +\
10721            '>'
10722
10723    def to_dict(self):
10724        return {
10725            'bind_interface': self.bind_interface,
10726            'database': self.database,
10727            'egress_filter': self.egress_filter,
10728            'healthy': self.healthy,
10729            'hostname': self.hostname,
10730            'id': self.id,
10731            'name': self.name,
10732            'override_database': self.override_database,
10733            'password': self.password,
10734            'port': self.port,
10735            'port_override': self.port_override,
10736            'schema': self.schema,
10737            'secret_store_id': self.secret_store_id,
10738            'tags': self.tags,
10739            'username': self.username,
10740        }
10741
10742    @classmethod
10743    def from_dict(cls, d):
10744        return cls(
10745            bind_interface=d.get('bind_interface'),
10746            database=d.get('database'),
10747            egress_filter=d.get('egress_filter'),
10748            healthy=d.get('healthy'),
10749            hostname=d.get('hostname'),
10750            id=d.get('id'),
10751            name=d.get('name'),
10752            override_database=d.get('override_database'),
10753            password=d.get('password'),
10754            port=d.get('port'),
10755            port_override=d.get('port_override'),
10756            schema=d.get('schema'),
10757            secret_store_id=d.get('secret_store_id'),
10758            tags=d.get('tags'),
10759            username=d.get('username'),
10760        )
10761
10762
10763class SSH:
10764    __slots__ = [
10765        'allow_deprecated_key_exchanges',
10766        'bind_interface',
10767        'egress_filter',
10768        'healthy',
10769        'hostname',
10770        'id',
10771        'key_type',
10772        'name',
10773        'port',
10774        'port_forwarding',
10775        'port_override',
10776        'public_key',
10777        'secret_store_id',
10778        'tags',
10779        'username',
10780    ]
10781
10782    def __init__(
10783        self,
10784        allow_deprecated_key_exchanges=None,
10785        bind_interface=None,
10786        egress_filter=None,
10787        healthy=None,
10788        hostname=None,
10789        id=None,
10790        key_type=None,
10791        name=None,
10792        port=None,
10793        port_forwarding=None,
10794        port_override=None,
10795        public_key=None,
10796        secret_store_id=None,
10797        tags=None,
10798        username=None,
10799    ):
10800        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10801        self.bind_interface = bind_interface if bind_interface is not None else ''
10802        '''
10803         Bind interface
10804        '''
10805        self.egress_filter = egress_filter if egress_filter is not None else ''
10806        '''
10807         A filter applied to the routing logic to pin datasource to nodes.
10808        '''
10809        self.healthy = healthy if healthy is not None else False
10810        '''
10811         True if the datasource is reachable and the credentials are valid.
10812        '''
10813        self.hostname = hostname if hostname is not None else ''
10814        self.id = id if id is not None else ''
10815        '''
10816         Unique identifier of the Resource.
10817        '''
10818        self.key_type = key_type if key_type is not None else ''
10819        self.name = name if name is not None else ''
10820        '''
10821         Unique human-readable name of the Resource.
10822        '''
10823        self.port = port if port is not None else 0
10824        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10825        self.port_override = port_override if port_override is not None else 0
10826        self.public_key = public_key if public_key is not None else ''
10827        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10828        '''
10829         ID of the secret store containing credentials for this resource, if any.
10830        '''
10831        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10832        '''
10833         Tags is a map of key, value pairs.
10834        '''
10835        self.username = username if username is not None else ''
10836
10837    def __repr__(self):
10838        return '<sdm.SSH ' + \
10839            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10840            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10841            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10842            'healthy: ' + repr(self.healthy) + ' ' +\
10843            'hostname: ' + repr(self.hostname) + ' ' +\
10844            'id: ' + repr(self.id) + ' ' +\
10845            'key_type: ' + repr(self.key_type) + ' ' +\
10846            'name: ' + repr(self.name) + ' ' +\
10847            'port: ' + repr(self.port) + ' ' +\
10848            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10849            'port_override: ' + repr(self.port_override) + ' ' +\
10850            'public_key: ' + repr(self.public_key) + ' ' +\
10851            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10852            'tags: ' + repr(self.tags) + ' ' +\
10853            'username: ' + repr(self.username) + ' ' +\
10854            '>'
10855
10856    def to_dict(self):
10857        return {
10858            'allow_deprecated_key_exchanges':
10859            self.allow_deprecated_key_exchanges,
10860            'bind_interface': self.bind_interface,
10861            'egress_filter': self.egress_filter,
10862            'healthy': self.healthy,
10863            'hostname': self.hostname,
10864            'id': self.id,
10865            'key_type': self.key_type,
10866            'name': self.name,
10867            'port': self.port,
10868            'port_forwarding': self.port_forwarding,
10869            'port_override': self.port_override,
10870            'public_key': self.public_key,
10871            'secret_store_id': self.secret_store_id,
10872            'tags': self.tags,
10873            'username': self.username,
10874        }
10875
10876    @classmethod
10877    def from_dict(cls, d):
10878        return cls(
10879            allow_deprecated_key_exchanges=d.get(
10880                'allow_deprecated_key_exchanges'),
10881            bind_interface=d.get('bind_interface'),
10882            egress_filter=d.get('egress_filter'),
10883            healthy=d.get('healthy'),
10884            hostname=d.get('hostname'),
10885            id=d.get('id'),
10886            key_type=d.get('key_type'),
10887            name=d.get('name'),
10888            port=d.get('port'),
10889            port_forwarding=d.get('port_forwarding'),
10890            port_override=d.get('port_override'),
10891            public_key=d.get('public_key'),
10892            secret_store_id=d.get('secret_store_id'),
10893            tags=d.get('tags'),
10894            username=d.get('username'),
10895        )
10896
10897
10898class SSHCert:
10899    __slots__ = [
10900        'allow_deprecated_key_exchanges',
10901        'bind_interface',
10902        'egress_filter',
10903        'healthy',
10904        'hostname',
10905        'id',
10906        'key_type',
10907        'name',
10908        'port',
10909        'port_forwarding',
10910        'port_override',
10911        'remote_identity_group_id',
10912        'remote_identity_healthcheck_username',
10913        'secret_store_id',
10914        'tags',
10915        'username',
10916    ]
10917
10918    def __init__(
10919        self,
10920        allow_deprecated_key_exchanges=None,
10921        bind_interface=None,
10922        egress_filter=None,
10923        healthy=None,
10924        hostname=None,
10925        id=None,
10926        key_type=None,
10927        name=None,
10928        port=None,
10929        port_forwarding=None,
10930        port_override=None,
10931        remote_identity_group_id=None,
10932        remote_identity_healthcheck_username=None,
10933        secret_store_id=None,
10934        tags=None,
10935        username=None,
10936    ):
10937        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10938        self.bind_interface = bind_interface if bind_interface is not None else ''
10939        '''
10940         Bind interface
10941        '''
10942        self.egress_filter = egress_filter if egress_filter is not None else ''
10943        '''
10944         A filter applied to the routing logic to pin datasource to nodes.
10945        '''
10946        self.healthy = healthy if healthy is not None else False
10947        '''
10948         True if the datasource is reachable and the credentials are valid.
10949        '''
10950        self.hostname = hostname if hostname is not None else ''
10951        self.id = id if id is not None else ''
10952        '''
10953         Unique identifier of the Resource.
10954        '''
10955        self.key_type = key_type if key_type is not None else ''
10956        self.name = name if name is not None else ''
10957        '''
10958         Unique human-readable name of the Resource.
10959        '''
10960        self.port = port if port is not None else 0
10961        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10962        self.port_override = port_override if port_override is not None else 0
10963        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10964        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10965        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10966        '''
10967         ID of the secret store containing credentials for this resource, if any.
10968        '''
10969        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10970        '''
10971         Tags is a map of key, value pairs.
10972        '''
10973        self.username = username if username is not None else ''
10974
10975    def __repr__(self):
10976        return '<sdm.SSHCert ' + \
10977            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10978            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10979            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10980            'healthy: ' + repr(self.healthy) + ' ' +\
10981            'hostname: ' + repr(self.hostname) + ' ' +\
10982            'id: ' + repr(self.id) + ' ' +\
10983            'key_type: ' + repr(self.key_type) + ' ' +\
10984            'name: ' + repr(self.name) + ' ' +\
10985            'port: ' + repr(self.port) + ' ' +\
10986            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10987            'port_override: ' + repr(self.port_override) + ' ' +\
10988            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10989            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10990            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10991            'tags: ' + repr(self.tags) + ' ' +\
10992            'username: ' + repr(self.username) + ' ' +\
10993            '>'
10994
10995    def to_dict(self):
10996        return {
10997            'allow_deprecated_key_exchanges':
10998            self.allow_deprecated_key_exchanges,
10999            'bind_interface': self.bind_interface,
11000            'egress_filter': self.egress_filter,
11001            'healthy': self.healthy,
11002            'hostname': self.hostname,
11003            'id': self.id,
11004            'key_type': self.key_type,
11005            'name': self.name,
11006            'port': self.port,
11007            'port_forwarding': self.port_forwarding,
11008            'port_override': self.port_override,
11009            'remote_identity_group_id': self.remote_identity_group_id,
11010            'remote_identity_healthcheck_username':
11011            self.remote_identity_healthcheck_username,
11012            'secret_store_id': self.secret_store_id,
11013            'tags': self.tags,
11014            'username': self.username,
11015        }
11016
11017    @classmethod
11018    def from_dict(cls, d):
11019        return cls(
11020            allow_deprecated_key_exchanges=d.get(
11021                'allow_deprecated_key_exchanges'),
11022            bind_interface=d.get('bind_interface'),
11023            egress_filter=d.get('egress_filter'),
11024            healthy=d.get('healthy'),
11025            hostname=d.get('hostname'),
11026            id=d.get('id'),
11027            key_type=d.get('key_type'),
11028            name=d.get('name'),
11029            port=d.get('port'),
11030            port_forwarding=d.get('port_forwarding'),
11031            port_override=d.get('port_override'),
11032            remote_identity_group_id=d.get('remote_identity_group_id'),
11033            remote_identity_healthcheck_username=d.get(
11034                'remote_identity_healthcheck_username'),
11035            secret_store_id=d.get('secret_store_id'),
11036            tags=d.get('tags'),
11037            username=d.get('username'),
11038        )
11039
11040
11041class SSHCustomerKey:
11042    __slots__ = [
11043        'allow_deprecated_key_exchanges',
11044        'bind_interface',
11045        'egress_filter',
11046        'healthy',
11047        'hostname',
11048        'id',
11049        'name',
11050        'port',
11051        'port_forwarding',
11052        'port_override',
11053        'private_key',
11054        'secret_store_id',
11055        'tags',
11056        'username',
11057    ]
11058
11059    def __init__(
11060        self,
11061        allow_deprecated_key_exchanges=None,
11062        bind_interface=None,
11063        egress_filter=None,
11064        healthy=None,
11065        hostname=None,
11066        id=None,
11067        name=None,
11068        port=None,
11069        port_forwarding=None,
11070        port_override=None,
11071        private_key=None,
11072        secret_store_id=None,
11073        tags=None,
11074        username=None,
11075    ):
11076        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11077        self.bind_interface = bind_interface if bind_interface is not None else ''
11078        '''
11079         Bind interface
11080        '''
11081        self.egress_filter = egress_filter if egress_filter is not None else ''
11082        '''
11083         A filter applied to the routing logic to pin datasource to nodes.
11084        '''
11085        self.healthy = healthy if healthy is not None else False
11086        '''
11087         True if the datasource is reachable and the credentials are valid.
11088        '''
11089        self.hostname = hostname if hostname is not None else ''
11090        self.id = id if id is not None else ''
11091        '''
11092         Unique identifier of the Resource.
11093        '''
11094        self.name = name if name is not None else ''
11095        '''
11096         Unique human-readable name of the Resource.
11097        '''
11098        self.port = port if port is not None else 0
11099        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11100        self.port_override = port_override if port_override is not None else 0
11101        self.private_key = private_key if private_key is not None else ''
11102        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11103        '''
11104         ID of the secret store containing credentials for this resource, if any.
11105        '''
11106        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11107        '''
11108         Tags is a map of key, value pairs.
11109        '''
11110        self.username = username if username is not None else ''
11111
11112    def __repr__(self):
11113        return '<sdm.SSHCustomerKey ' + \
11114            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11115            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11116            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11117            'healthy: ' + repr(self.healthy) + ' ' +\
11118            'hostname: ' + repr(self.hostname) + ' ' +\
11119            'id: ' + repr(self.id) + ' ' +\
11120            'name: ' + repr(self.name) + ' ' +\
11121            'port: ' + repr(self.port) + ' ' +\
11122            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11123            'port_override: ' + repr(self.port_override) + ' ' +\
11124            'private_key: ' + repr(self.private_key) + ' ' +\
11125            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11126            'tags: ' + repr(self.tags) + ' ' +\
11127            'username: ' + repr(self.username) + ' ' +\
11128            '>'
11129
11130    def to_dict(self):
11131        return {
11132            'allow_deprecated_key_exchanges':
11133            self.allow_deprecated_key_exchanges,
11134            'bind_interface': self.bind_interface,
11135            'egress_filter': self.egress_filter,
11136            'healthy': self.healthy,
11137            'hostname': self.hostname,
11138            'id': self.id,
11139            'name': self.name,
11140            'port': self.port,
11141            'port_forwarding': self.port_forwarding,
11142            'port_override': self.port_override,
11143            'private_key': self.private_key,
11144            'secret_store_id': self.secret_store_id,
11145            'tags': self.tags,
11146            'username': self.username,
11147        }
11148
11149    @classmethod
11150    def from_dict(cls, d):
11151        return cls(
11152            allow_deprecated_key_exchanges=d.get(
11153                'allow_deprecated_key_exchanges'),
11154            bind_interface=d.get('bind_interface'),
11155            egress_filter=d.get('egress_filter'),
11156            healthy=d.get('healthy'),
11157            hostname=d.get('hostname'),
11158            id=d.get('id'),
11159            name=d.get('name'),
11160            port=d.get('port'),
11161            port_forwarding=d.get('port_forwarding'),
11162            port_override=d.get('port_override'),
11163            private_key=d.get('private_key'),
11164            secret_store_id=d.get('secret_store_id'),
11165            tags=d.get('tags'),
11166            username=d.get('username'),
11167        )
11168
11169
11170class SecretStoreCreateResponse:
11171    '''
11172         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11173    '''
11174    __slots__ = [
11175        'meta',
11176        'rate_limit',
11177        'secret_store',
11178    ]
11179
11180    def __init__(
11181        self,
11182        meta=None,
11183        rate_limit=None,
11184        secret_store=None,
11185    ):
11186        self.meta = meta if meta is not None else None
11187        '''
11188         Reserved for future use.
11189        '''
11190        self.rate_limit = rate_limit if rate_limit is not None else None
11191        '''
11192         Rate limit information.
11193        '''
11194        self.secret_store = secret_store if secret_store is not None else None
11195        '''
11196         The created SecretStore.
11197        '''
11198
11199    def __repr__(self):
11200        return '<sdm.SecretStoreCreateResponse ' + \
11201            'meta: ' + repr(self.meta) + ' ' +\
11202            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11203            'secret_store: ' + repr(self.secret_store) + ' ' +\
11204            '>'
11205
11206    def to_dict(self):
11207        return {
11208            'meta': self.meta,
11209            'rate_limit': self.rate_limit,
11210            'secret_store': self.secret_store,
11211        }
11212
11213    @classmethod
11214    def from_dict(cls, d):
11215        return cls(
11216            meta=d.get('meta'),
11217            rate_limit=d.get('rate_limit'),
11218            secret_store=d.get('secret_store'),
11219        )
11220
11221
11222class SecretStoreDeleteResponse:
11223    '''
11224         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11225    '''
11226    __slots__ = [
11227        'meta',
11228        'rate_limit',
11229    ]
11230
11231    def __init__(
11232        self,
11233        meta=None,
11234        rate_limit=None,
11235    ):
11236        self.meta = meta if meta is not None else None
11237        '''
11238         Reserved for future use.
11239        '''
11240        self.rate_limit = rate_limit if rate_limit is not None else None
11241        '''
11242         Rate limit information.
11243        '''
11244
11245    def __repr__(self):
11246        return '<sdm.SecretStoreDeleteResponse ' + \
11247            'meta: ' + repr(self.meta) + ' ' +\
11248            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11249            '>'
11250
11251    def to_dict(self):
11252        return {
11253            'meta': self.meta,
11254            'rate_limit': self.rate_limit,
11255        }
11256
11257    @classmethod
11258    def from_dict(cls, d):
11259        return cls(
11260            meta=d.get('meta'),
11261            rate_limit=d.get('rate_limit'),
11262        )
11263
11264
11265class SecretStoreGetResponse:
11266    '''
11267         SecretStoreGetResponse returns a requested SecretStore.
11268    '''
11269    __slots__ = [
11270        'meta',
11271        'rate_limit',
11272        'secret_store',
11273    ]
11274
11275    def __init__(
11276        self,
11277        meta=None,
11278        rate_limit=None,
11279        secret_store=None,
11280    ):
11281        self.meta = meta if meta is not None else None
11282        '''
11283         Reserved for future use.
11284        '''
11285        self.rate_limit = rate_limit if rate_limit is not None else None
11286        '''
11287         Rate limit information.
11288        '''
11289        self.secret_store = secret_store if secret_store is not None else None
11290        '''
11291         The requested SecretStore.
11292        '''
11293
11294    def __repr__(self):
11295        return '<sdm.SecretStoreGetResponse ' + \
11296            'meta: ' + repr(self.meta) + ' ' +\
11297            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11298            'secret_store: ' + repr(self.secret_store) + ' ' +\
11299            '>'
11300
11301    def to_dict(self):
11302        return {
11303            'meta': self.meta,
11304            'rate_limit': self.rate_limit,
11305            'secret_store': self.secret_store,
11306        }
11307
11308    @classmethod
11309    def from_dict(cls, d):
11310        return cls(
11311            meta=d.get('meta'),
11312            rate_limit=d.get('rate_limit'),
11313            secret_store=d.get('secret_store'),
11314        )
11315
11316
11317class SecretStoreUpdateResponse:
11318    '''
11319         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11320     a SecretStoreUpdateRequest.
11321    '''
11322    __slots__ = [
11323        'meta',
11324        'rate_limit',
11325        'secret_store',
11326    ]
11327
11328    def __init__(
11329        self,
11330        meta=None,
11331        rate_limit=None,
11332        secret_store=None,
11333    ):
11334        self.meta = meta if meta is not None else None
11335        '''
11336         Reserved for future use.
11337        '''
11338        self.rate_limit = rate_limit if rate_limit is not None else None
11339        '''
11340         Rate limit information.
11341        '''
11342        self.secret_store = secret_store if secret_store is not None else None
11343        '''
11344         The updated SecretStore.
11345        '''
11346
11347    def __repr__(self):
11348        return '<sdm.SecretStoreUpdateResponse ' + \
11349            'meta: ' + repr(self.meta) + ' ' +\
11350            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11351            'secret_store: ' + repr(self.secret_store) + ' ' +\
11352            '>'
11353
11354    def to_dict(self):
11355        return {
11356            'meta': self.meta,
11357            'rate_limit': self.rate_limit,
11358            'secret_store': self.secret_store,
11359        }
11360
11361    @classmethod
11362    def from_dict(cls, d):
11363        return cls(
11364            meta=d.get('meta'),
11365            rate_limit=d.get('rate_limit'),
11366            secret_store=d.get('secret_store'),
11367        )
11368
11369
11370class Service:
11371    '''
11372         A Service is a service account that can connect to resources they are granted
11373     directly, or granted via roles. Services are typically automated jobs.
11374    '''
11375    __slots__ = [
11376        'id',
11377        'name',
11378        'suspended',
11379        'tags',
11380    ]
11381
11382    def __init__(
11383        self,
11384        id=None,
11385        name=None,
11386        suspended=None,
11387        tags=None,
11388    ):
11389        self.id = id if id is not None else ''
11390        '''
11391         Unique identifier of the Service.
11392        '''
11393        self.name = name if name is not None else ''
11394        '''
11395         Unique human-readable name of the Service.
11396        '''
11397        self.suspended = suspended if suspended is not None else False
11398        '''
11399         The Service's suspended state.
11400        '''
11401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11402        '''
11403         Tags is a map of key, value pairs.
11404        '''
11405
11406    def __repr__(self):
11407        return '<sdm.Service ' + \
11408            'id: ' + repr(self.id) + ' ' +\
11409            'name: ' + repr(self.name) + ' ' +\
11410            'suspended: ' + repr(self.suspended) + ' ' +\
11411            'tags: ' + repr(self.tags) + ' ' +\
11412            '>'
11413
11414    def to_dict(self):
11415        return {
11416            'id': self.id,
11417            'name': self.name,
11418            'suspended': self.suspended,
11419            'tags': self.tags,
11420        }
11421
11422    @classmethod
11423    def from_dict(cls, d):
11424        return cls(
11425            id=d.get('id'),
11426            name=d.get('name'),
11427            suspended=d.get('suspended'),
11428            tags=d.get('tags'),
11429        )
11430
11431
11432class SingleStore:
11433    __slots__ = [
11434        'bind_interface',
11435        'database',
11436        'egress_filter',
11437        'healthy',
11438        'hostname',
11439        'id',
11440        'name',
11441        'password',
11442        'port',
11443        'port_override',
11444        'secret_store_id',
11445        'tags',
11446        'username',
11447    ]
11448
11449    def __init__(
11450        self,
11451        bind_interface=None,
11452        database=None,
11453        egress_filter=None,
11454        healthy=None,
11455        hostname=None,
11456        id=None,
11457        name=None,
11458        password=None,
11459        port=None,
11460        port_override=None,
11461        secret_store_id=None,
11462        tags=None,
11463        username=None,
11464    ):
11465        self.bind_interface = bind_interface if bind_interface is not None else ''
11466        '''
11467         Bind interface
11468        '''
11469        self.database = database if database is not None else ''
11470        self.egress_filter = egress_filter if egress_filter is not None else ''
11471        '''
11472         A filter applied to the routing logic to pin datasource to nodes.
11473        '''
11474        self.healthy = healthy if healthy is not None else False
11475        '''
11476         True if the datasource is reachable and the credentials are valid.
11477        '''
11478        self.hostname = hostname if hostname is not None else ''
11479        self.id = id if id is not None else ''
11480        '''
11481         Unique identifier of the Resource.
11482        '''
11483        self.name = name if name is not None else ''
11484        '''
11485         Unique human-readable name of the Resource.
11486        '''
11487        self.password = password if password is not None else ''
11488        self.port = port if port is not None else 0
11489        self.port_override = port_override if port_override is not None else 0
11490        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11491        '''
11492         ID of the secret store containing credentials for this resource, if any.
11493        '''
11494        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11495        '''
11496         Tags is a map of key, value pairs.
11497        '''
11498        self.username = username if username is not None else ''
11499
11500    def __repr__(self):
11501        return '<sdm.SingleStore ' + \
11502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11503            'database: ' + repr(self.database) + ' ' +\
11504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11505            'healthy: ' + repr(self.healthy) + ' ' +\
11506            'hostname: ' + repr(self.hostname) + ' ' +\
11507            'id: ' + repr(self.id) + ' ' +\
11508            'name: ' + repr(self.name) + ' ' +\
11509            'password: ' + repr(self.password) + ' ' +\
11510            'port: ' + repr(self.port) + ' ' +\
11511            'port_override: ' + repr(self.port_override) + ' ' +\
11512            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11513            'tags: ' + repr(self.tags) + ' ' +\
11514            'username: ' + repr(self.username) + ' ' +\
11515            '>'
11516
11517    def to_dict(self):
11518        return {
11519            'bind_interface': self.bind_interface,
11520            'database': self.database,
11521            'egress_filter': self.egress_filter,
11522            'healthy': self.healthy,
11523            'hostname': self.hostname,
11524            'id': self.id,
11525            'name': self.name,
11526            'password': self.password,
11527            'port': self.port,
11528            'port_override': self.port_override,
11529            'secret_store_id': self.secret_store_id,
11530            'tags': self.tags,
11531            'username': self.username,
11532        }
11533
11534    @classmethod
11535    def from_dict(cls, d):
11536        return cls(
11537            bind_interface=d.get('bind_interface'),
11538            database=d.get('database'),
11539            egress_filter=d.get('egress_filter'),
11540            healthy=d.get('healthy'),
11541            hostname=d.get('hostname'),
11542            id=d.get('id'),
11543            name=d.get('name'),
11544            password=d.get('password'),
11545            port=d.get('port'),
11546            port_override=d.get('port_override'),
11547            secret_store_id=d.get('secret_store_id'),
11548            tags=d.get('tags'),
11549            username=d.get('username'),
11550        )
11551
11552
11553class Snowflake:
11554    __slots__ = [
11555        'bind_interface',
11556        'database',
11557        'egress_filter',
11558        'healthy',
11559        'hostname',
11560        'id',
11561        'name',
11562        'password',
11563        'port_override',
11564        'schema',
11565        'secret_store_id',
11566        'tags',
11567        'username',
11568    ]
11569
11570    def __init__(
11571        self,
11572        bind_interface=None,
11573        database=None,
11574        egress_filter=None,
11575        healthy=None,
11576        hostname=None,
11577        id=None,
11578        name=None,
11579        password=None,
11580        port_override=None,
11581        schema=None,
11582        secret_store_id=None,
11583        tags=None,
11584        username=None,
11585    ):
11586        self.bind_interface = bind_interface if bind_interface is not None else ''
11587        '''
11588         Bind interface
11589        '''
11590        self.database = database if database is not None else ''
11591        self.egress_filter = egress_filter if egress_filter is not None else ''
11592        '''
11593         A filter applied to the routing logic to pin datasource to nodes.
11594        '''
11595        self.healthy = healthy if healthy is not None else False
11596        '''
11597         True if the datasource is reachable and the credentials are valid.
11598        '''
11599        self.hostname = hostname if hostname is not None else ''
11600        self.id = id if id is not None else ''
11601        '''
11602         Unique identifier of the Resource.
11603        '''
11604        self.name = name if name is not None else ''
11605        '''
11606         Unique human-readable name of the Resource.
11607        '''
11608        self.password = password if password is not None else ''
11609        self.port_override = port_override if port_override is not None else 0
11610        self.schema = schema if schema is not None else ''
11611        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11612        '''
11613         ID of the secret store containing credentials for this resource, if any.
11614        '''
11615        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11616        '''
11617         Tags is a map of key, value pairs.
11618        '''
11619        self.username = username if username is not None else ''
11620
11621    def __repr__(self):
11622        return '<sdm.Snowflake ' + \
11623            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11624            'database: ' + repr(self.database) + ' ' +\
11625            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11626            'healthy: ' + repr(self.healthy) + ' ' +\
11627            'hostname: ' + repr(self.hostname) + ' ' +\
11628            'id: ' + repr(self.id) + ' ' +\
11629            'name: ' + repr(self.name) + ' ' +\
11630            'password: ' + repr(self.password) + ' ' +\
11631            'port_override: ' + repr(self.port_override) + ' ' +\
11632            'schema: ' + repr(self.schema) + ' ' +\
11633            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11634            'tags: ' + repr(self.tags) + ' ' +\
11635            'username: ' + repr(self.username) + ' ' +\
11636            '>'
11637
11638    def to_dict(self):
11639        return {
11640            'bind_interface': self.bind_interface,
11641            'database': self.database,
11642            'egress_filter': self.egress_filter,
11643            'healthy': self.healthy,
11644            'hostname': self.hostname,
11645            'id': self.id,
11646            'name': self.name,
11647            'password': self.password,
11648            'port_override': self.port_override,
11649            'schema': self.schema,
11650            'secret_store_id': self.secret_store_id,
11651            'tags': self.tags,
11652            'username': self.username,
11653        }
11654
11655    @classmethod
11656    def from_dict(cls, d):
11657        return cls(
11658            bind_interface=d.get('bind_interface'),
11659            database=d.get('database'),
11660            egress_filter=d.get('egress_filter'),
11661            healthy=d.get('healthy'),
11662            hostname=d.get('hostname'),
11663            id=d.get('id'),
11664            name=d.get('name'),
11665            password=d.get('password'),
11666            port_override=d.get('port_override'),
11667            schema=d.get('schema'),
11668            secret_store_id=d.get('secret_store_id'),
11669            tags=d.get('tags'),
11670            username=d.get('username'),
11671        )
11672
11673
11674class Snowsight:
11675    '''
11676    Snowsight is currently unstable, and its API may change, or it may be removed,
11677    without a major version bump.
11678    '''
11679    __slots__ = [
11680        'bind_interface',
11681        'egress_filter',
11682        'healthcheck_username',
11683        'healthy',
11684        'id',
11685        'name',
11686        'port_override',
11687        'samlmetadata',
11688        'secret_store_id',
11689        'subdomain',
11690        'tags',
11691    ]
11692
11693    def __init__(
11694        self,
11695        bind_interface=None,
11696        egress_filter=None,
11697        healthcheck_username=None,
11698        healthy=None,
11699        id=None,
11700        name=None,
11701        port_override=None,
11702        samlmetadata=None,
11703        secret_store_id=None,
11704        subdomain=None,
11705        tags=None,
11706    ):
11707        self.bind_interface = bind_interface if bind_interface is not None else ''
11708        '''
11709         Bind interface
11710        '''
11711        self.egress_filter = egress_filter if egress_filter is not None else ''
11712        '''
11713         A filter applied to the routing logic to pin datasource to nodes.
11714        '''
11715        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11716        self.healthy = healthy if healthy is not None else False
11717        '''
11718         True if the datasource is reachable and the credentials are valid.
11719        '''
11720        self.id = id if id is not None else ''
11721        '''
11722         Unique identifier of the Resource.
11723        '''
11724        self.name = name if name is not None else ''
11725        '''
11726         Unique human-readable name of the Resource.
11727        '''
11728        self.port_override = port_override if port_override is not None else 0
11729        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11730        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11731        '''
11732         ID of the secret store containing credentials for this resource, if any.
11733        '''
11734        self.subdomain = subdomain if subdomain is not None else ''
11735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11736        '''
11737         Tags is a map of key, value pairs.
11738        '''
11739
11740    def __repr__(self):
11741        return '<sdm.Snowsight ' + \
11742            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11743            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11744            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11745            'healthy: ' + repr(self.healthy) + ' ' +\
11746            'id: ' + repr(self.id) + ' ' +\
11747            'name: ' + repr(self.name) + ' ' +\
11748            'port_override: ' + repr(self.port_override) + ' ' +\
11749            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11750            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11751            'subdomain: ' + repr(self.subdomain) + ' ' +\
11752            'tags: ' + repr(self.tags) + ' ' +\
11753            '>'
11754
11755    def to_dict(self):
11756        return {
11757            'bind_interface': self.bind_interface,
11758            'egress_filter': self.egress_filter,
11759            'healthcheck_username': self.healthcheck_username,
11760            'healthy': self.healthy,
11761            'id': self.id,
11762            'name': self.name,
11763            'port_override': self.port_override,
11764            'samlmetadata': self.samlmetadata,
11765            'secret_store_id': self.secret_store_id,
11766            'subdomain': self.subdomain,
11767            'tags': self.tags,
11768        }
11769
11770    @classmethod
11771    def from_dict(cls, d):
11772        return cls(
11773            bind_interface=d.get('bind_interface'),
11774            egress_filter=d.get('egress_filter'),
11775            healthcheck_username=d.get('healthcheck_username'),
11776            healthy=d.get('healthy'),
11777            id=d.get('id'),
11778            name=d.get('name'),
11779            port_override=d.get('port_override'),
11780            samlmetadata=d.get('samlmetadata'),
11781            secret_store_id=d.get('secret_store_id'),
11782            subdomain=d.get('subdomain'),
11783            tags=d.get('tags'),
11784        )
11785
11786
11787class Sybase:
11788    __slots__ = [
11789        'bind_interface',
11790        'egress_filter',
11791        'healthy',
11792        'hostname',
11793        'id',
11794        'name',
11795        'password',
11796        'port',
11797        'port_override',
11798        'secret_store_id',
11799        'tags',
11800        'username',
11801    ]
11802
11803    def __init__(
11804        self,
11805        bind_interface=None,
11806        egress_filter=None,
11807        healthy=None,
11808        hostname=None,
11809        id=None,
11810        name=None,
11811        password=None,
11812        port=None,
11813        port_override=None,
11814        secret_store_id=None,
11815        tags=None,
11816        username=None,
11817    ):
11818        self.bind_interface = bind_interface if bind_interface is not None else ''
11819        '''
11820         Bind interface
11821        '''
11822        self.egress_filter = egress_filter if egress_filter is not None else ''
11823        '''
11824         A filter applied to the routing logic to pin datasource to nodes.
11825        '''
11826        self.healthy = healthy if healthy is not None else False
11827        '''
11828         True if the datasource is reachable and the credentials are valid.
11829        '''
11830        self.hostname = hostname if hostname is not None else ''
11831        self.id = id if id is not None else ''
11832        '''
11833         Unique identifier of the Resource.
11834        '''
11835        self.name = name if name is not None else ''
11836        '''
11837         Unique human-readable name of the Resource.
11838        '''
11839        self.password = password if password is not None else ''
11840        self.port = port if port is not None else 0
11841        self.port_override = port_override if port_override is not None else 0
11842        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11843        '''
11844         ID of the secret store containing credentials for this resource, if any.
11845        '''
11846        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11847        '''
11848         Tags is a map of key, value pairs.
11849        '''
11850        self.username = username if username is not None else ''
11851
11852    def __repr__(self):
11853        return '<sdm.Sybase ' + \
11854            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11855            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11856            'healthy: ' + repr(self.healthy) + ' ' +\
11857            'hostname: ' + repr(self.hostname) + ' ' +\
11858            'id: ' + repr(self.id) + ' ' +\
11859            'name: ' + repr(self.name) + ' ' +\
11860            'password: ' + repr(self.password) + ' ' +\
11861            'port: ' + repr(self.port) + ' ' +\
11862            'port_override: ' + repr(self.port_override) + ' ' +\
11863            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11864            'tags: ' + repr(self.tags) + ' ' +\
11865            'username: ' + repr(self.username) + ' ' +\
11866            '>'
11867
11868    def to_dict(self):
11869        return {
11870            'bind_interface': self.bind_interface,
11871            'egress_filter': self.egress_filter,
11872            'healthy': self.healthy,
11873            'hostname': self.hostname,
11874            'id': self.id,
11875            'name': self.name,
11876            'password': self.password,
11877            'port': self.port,
11878            'port_override': self.port_override,
11879            'secret_store_id': self.secret_store_id,
11880            'tags': self.tags,
11881            'username': self.username,
11882        }
11883
11884    @classmethod
11885    def from_dict(cls, d):
11886        return cls(
11887            bind_interface=d.get('bind_interface'),
11888            egress_filter=d.get('egress_filter'),
11889            healthy=d.get('healthy'),
11890            hostname=d.get('hostname'),
11891            id=d.get('id'),
11892            name=d.get('name'),
11893            password=d.get('password'),
11894            port=d.get('port'),
11895            port_override=d.get('port_override'),
11896            secret_store_id=d.get('secret_store_id'),
11897            tags=d.get('tags'),
11898            username=d.get('username'),
11899        )
11900
11901
11902class SybaseIQ:
11903    __slots__ = [
11904        'bind_interface',
11905        'egress_filter',
11906        'healthy',
11907        'hostname',
11908        'id',
11909        'name',
11910        'password',
11911        'port',
11912        'port_override',
11913        'secret_store_id',
11914        'tags',
11915        'username',
11916    ]
11917
11918    def __init__(
11919        self,
11920        bind_interface=None,
11921        egress_filter=None,
11922        healthy=None,
11923        hostname=None,
11924        id=None,
11925        name=None,
11926        password=None,
11927        port=None,
11928        port_override=None,
11929        secret_store_id=None,
11930        tags=None,
11931        username=None,
11932    ):
11933        self.bind_interface = bind_interface if bind_interface is not None else ''
11934        '''
11935         Bind interface
11936        '''
11937        self.egress_filter = egress_filter if egress_filter is not None else ''
11938        '''
11939         A filter applied to the routing logic to pin datasource to nodes.
11940        '''
11941        self.healthy = healthy if healthy is not None else False
11942        '''
11943         True if the datasource is reachable and the credentials are valid.
11944        '''
11945        self.hostname = hostname if hostname is not None else ''
11946        self.id = id if id is not None else ''
11947        '''
11948         Unique identifier of the Resource.
11949        '''
11950        self.name = name if name is not None else ''
11951        '''
11952         Unique human-readable name of the Resource.
11953        '''
11954        self.password = password if password is not None else ''
11955        self.port = port if port is not None else 0
11956        self.port_override = port_override if port_override is not None else 0
11957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11958        '''
11959         ID of the secret store containing credentials for this resource, if any.
11960        '''
11961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11962        '''
11963         Tags is a map of key, value pairs.
11964        '''
11965        self.username = username if username is not None else ''
11966
11967    def __repr__(self):
11968        return '<sdm.SybaseIQ ' + \
11969            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11970            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11971            'healthy: ' + repr(self.healthy) + ' ' +\
11972            'hostname: ' + repr(self.hostname) + ' ' +\
11973            'id: ' + repr(self.id) + ' ' +\
11974            'name: ' + repr(self.name) + ' ' +\
11975            'password: ' + repr(self.password) + ' ' +\
11976            'port: ' + repr(self.port) + ' ' +\
11977            'port_override: ' + repr(self.port_override) + ' ' +\
11978            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11979            'tags: ' + repr(self.tags) + ' ' +\
11980            'username: ' + repr(self.username) + ' ' +\
11981            '>'
11982
11983    def to_dict(self):
11984        return {
11985            'bind_interface': self.bind_interface,
11986            'egress_filter': self.egress_filter,
11987            'healthy': self.healthy,
11988            'hostname': self.hostname,
11989            'id': self.id,
11990            'name': self.name,
11991            'password': self.password,
11992            'port': self.port,
11993            'port_override': self.port_override,
11994            'secret_store_id': self.secret_store_id,
11995            'tags': self.tags,
11996            'username': self.username,
11997        }
11998
11999    @classmethod
12000    def from_dict(cls, d):
12001        return cls(
12002            bind_interface=d.get('bind_interface'),
12003            egress_filter=d.get('egress_filter'),
12004            healthy=d.get('healthy'),
12005            hostname=d.get('hostname'),
12006            id=d.get('id'),
12007            name=d.get('name'),
12008            password=d.get('password'),
12009            port=d.get('port'),
12010            port_override=d.get('port_override'),
12011            secret_store_id=d.get('secret_store_id'),
12012            tags=d.get('tags'),
12013            username=d.get('username'),
12014        )
12015
12016
12017class Tag:
12018    __slots__ = [
12019        'name',
12020        'value',
12021    ]
12022
12023    def __init__(
12024        self,
12025        name=None,
12026        value=None,
12027    ):
12028        self.name = name if name is not None else ''
12029        self.value = value if value is not None else ''
12030
12031    def __repr__(self):
12032        return '<sdm.Tag ' + \
12033            'name: ' + repr(self.name) + ' ' +\
12034            'value: ' + repr(self.value) + ' ' +\
12035            '>'
12036
12037    def to_dict(self):
12038        return {
12039            'name': self.name,
12040            'value': self.value,
12041        }
12042
12043    @classmethod
12044    def from_dict(cls, d):
12045        return cls(
12046            name=d.get('name'),
12047            value=d.get('value'),
12048        )
12049
12050
12051class Teradata:
12052    __slots__ = [
12053        'bind_interface',
12054        'egress_filter',
12055        'healthy',
12056        'hostname',
12057        'id',
12058        'name',
12059        'password',
12060        'port',
12061        'port_override',
12062        'secret_store_id',
12063        'tags',
12064        'username',
12065    ]
12066
12067    def __init__(
12068        self,
12069        bind_interface=None,
12070        egress_filter=None,
12071        healthy=None,
12072        hostname=None,
12073        id=None,
12074        name=None,
12075        password=None,
12076        port=None,
12077        port_override=None,
12078        secret_store_id=None,
12079        tags=None,
12080        username=None,
12081    ):
12082        self.bind_interface = bind_interface if bind_interface is not None else ''
12083        '''
12084         Bind interface
12085        '''
12086        self.egress_filter = egress_filter if egress_filter is not None else ''
12087        '''
12088         A filter applied to the routing logic to pin datasource to nodes.
12089        '''
12090        self.healthy = healthy if healthy is not None else False
12091        '''
12092         True if the datasource is reachable and the credentials are valid.
12093        '''
12094        self.hostname = hostname if hostname is not None else ''
12095        self.id = id if id is not None else ''
12096        '''
12097         Unique identifier of the Resource.
12098        '''
12099        self.name = name if name is not None else ''
12100        '''
12101         Unique human-readable name of the Resource.
12102        '''
12103        self.password = password if password is not None else ''
12104        self.port = port if port is not None else 0
12105        self.port_override = port_override if port_override is not None else 0
12106        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12107        '''
12108         ID of the secret store containing credentials for this resource, if any.
12109        '''
12110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12111        '''
12112         Tags is a map of key, value pairs.
12113        '''
12114        self.username = username if username is not None else ''
12115
12116    def __repr__(self):
12117        return '<sdm.Teradata ' + \
12118            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12119            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12120            'healthy: ' + repr(self.healthy) + ' ' +\
12121            'hostname: ' + repr(self.hostname) + ' ' +\
12122            'id: ' + repr(self.id) + ' ' +\
12123            'name: ' + repr(self.name) + ' ' +\
12124            'password: ' + repr(self.password) + ' ' +\
12125            'port: ' + repr(self.port) + ' ' +\
12126            'port_override: ' + repr(self.port_override) + ' ' +\
12127            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12128            'tags: ' + repr(self.tags) + ' ' +\
12129            'username: ' + repr(self.username) + ' ' +\
12130            '>'
12131
12132    def to_dict(self):
12133        return {
12134            'bind_interface': self.bind_interface,
12135            'egress_filter': self.egress_filter,
12136            'healthy': self.healthy,
12137            'hostname': self.hostname,
12138            'id': self.id,
12139            'name': self.name,
12140            'password': self.password,
12141            'port': self.port,
12142            'port_override': self.port_override,
12143            'secret_store_id': self.secret_store_id,
12144            'tags': self.tags,
12145            'username': self.username,
12146        }
12147
12148    @classmethod
12149    def from_dict(cls, d):
12150        return cls(
12151            bind_interface=d.get('bind_interface'),
12152            egress_filter=d.get('egress_filter'),
12153            healthy=d.get('healthy'),
12154            hostname=d.get('hostname'),
12155            id=d.get('id'),
12156            name=d.get('name'),
12157            password=d.get('password'),
12158            port=d.get('port'),
12159            port_override=d.get('port_override'),
12160            secret_store_id=d.get('secret_store_id'),
12161            tags=d.get('tags'),
12162            username=d.get('username'),
12163        )
12164
12165
12166class UpdateResponseMetadata:
12167    '''
12168         UpdateResponseMetadata is reserved for future use.
12169    '''
12170    __slots__ = []
12171
12172    def __init__(self, ):
12173        pass
12174
12175    def __repr__(self):
12176        return '<sdm.UpdateResponseMetadata ' + \
12177            '>'
12178
12179    def to_dict(self):
12180        return {}
12181
12182    @classmethod
12183    def from_dict(cls, d):
12184        return cls()
12185
12186
12187class User:
12188    '''
12189         A User can connect to resources they are granted directly, or granted
12190     via roles.
12191    '''
12192    __slots__ = [
12193        'email',
12194        'first_name',
12195        'id',
12196        'last_name',
12197        'suspended',
12198        'tags',
12199    ]
12200
12201    def __init__(
12202        self,
12203        email=None,
12204        first_name=None,
12205        id=None,
12206        last_name=None,
12207        suspended=None,
12208        tags=None,
12209    ):
12210        self.email = email if email is not None else ''
12211        '''
12212         The User's email address. Must be unique.
12213        '''
12214        self.first_name = first_name if first_name is not None else ''
12215        '''
12216         The User's first name.
12217        '''
12218        self.id = id if id is not None else ''
12219        '''
12220         Unique identifier of the User.
12221        '''
12222        self.last_name = last_name if last_name is not None else ''
12223        '''
12224         The User's last name.
12225        '''
12226        self.suspended = suspended if suspended is not None else False
12227        '''
12228         The User's suspended state.
12229        '''
12230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12231        '''
12232         Tags is a map of key, value pairs.
12233        '''
12234
12235    def __repr__(self):
12236        return '<sdm.User ' + \
12237            'email: ' + repr(self.email) + ' ' +\
12238            'first_name: ' + repr(self.first_name) + ' ' +\
12239            'id: ' + repr(self.id) + ' ' +\
12240            'last_name: ' + repr(self.last_name) + ' ' +\
12241            'suspended: ' + repr(self.suspended) + ' ' +\
12242            'tags: ' + repr(self.tags) + ' ' +\
12243            '>'
12244
12245    def to_dict(self):
12246        return {
12247            'email': self.email,
12248            'first_name': self.first_name,
12249            'id': self.id,
12250            'last_name': self.last_name,
12251            'suspended': self.suspended,
12252            'tags': self.tags,
12253        }
12254
12255    @classmethod
12256    def from_dict(cls, d):
12257        return cls(
12258            email=d.get('email'),
12259            first_name=d.get('first_name'),
12260            id=d.get('id'),
12261            last_name=d.get('last_name'),
12262            suspended=d.get('suspended'),
12263            tags=d.get('tags'),
12264        )
12265
12266
12267class VaultAppRoleStore:
12268    __slots__ = [
12269        'id',
12270        'name',
12271        'namespace',
12272        'server_address',
12273        'tags',
12274    ]
12275
12276    def __init__(
12277        self,
12278        id=None,
12279        name=None,
12280        namespace=None,
12281        server_address=None,
12282        tags=None,
12283    ):
12284        self.id = id if id is not None else ''
12285        '''
12286         Unique identifier of the SecretStore.
12287        '''
12288        self.name = name if name is not None else ''
12289        '''
12290         Unique human-readable name of the SecretStore.
12291        '''
12292        self.namespace = namespace if namespace is not None else ''
12293        self.server_address = server_address if server_address is not None else ''
12294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12295        '''
12296         Tags is a map of key, value pairs.
12297        '''
12298
12299    def __repr__(self):
12300        return '<sdm.VaultAppRoleStore ' + \
12301            'id: ' + repr(self.id) + ' ' +\
12302            'name: ' + repr(self.name) + ' ' +\
12303            'namespace: ' + repr(self.namespace) + ' ' +\
12304            'server_address: ' + repr(self.server_address) + ' ' +\
12305            'tags: ' + repr(self.tags) + ' ' +\
12306            '>'
12307
12308    def to_dict(self):
12309        return {
12310            'id': self.id,
12311            'name': self.name,
12312            'namespace': self.namespace,
12313            'server_address': self.server_address,
12314            'tags': self.tags,
12315        }
12316
12317    @classmethod
12318    def from_dict(cls, d):
12319        return cls(
12320            id=d.get('id'),
12321            name=d.get('name'),
12322            namespace=d.get('namespace'),
12323            server_address=d.get('server_address'),
12324            tags=d.get('tags'),
12325        )
12326
12327
12328class VaultTLSStore:
12329    __slots__ = [
12330        'ca_cert_path',
12331        'client_cert_path',
12332        'client_key_path',
12333        'id',
12334        'name',
12335        'namespace',
12336        'server_address',
12337        'tags',
12338    ]
12339
12340    def __init__(
12341        self,
12342        ca_cert_path=None,
12343        client_cert_path=None,
12344        client_key_path=None,
12345        id=None,
12346        name=None,
12347        namespace=None,
12348        server_address=None,
12349        tags=None,
12350    ):
12351        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12352        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12353        self.client_key_path = client_key_path if client_key_path is not None else ''
12354        self.id = id if id is not None else ''
12355        '''
12356         Unique identifier of the SecretStore.
12357        '''
12358        self.name = name if name is not None else ''
12359        '''
12360         Unique human-readable name of the SecretStore.
12361        '''
12362        self.namespace = namespace if namespace is not None else ''
12363        self.server_address = server_address if server_address is not None else ''
12364        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12365        '''
12366         Tags is a map of key, value pairs.
12367        '''
12368
12369    def __repr__(self):
12370        return '<sdm.VaultTLSStore ' + \
12371            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12372            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12373            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12374            'id: ' + repr(self.id) + ' ' +\
12375            'name: ' + repr(self.name) + ' ' +\
12376            'namespace: ' + repr(self.namespace) + ' ' +\
12377            'server_address: ' + repr(self.server_address) + ' ' +\
12378            'tags: ' + repr(self.tags) + ' ' +\
12379            '>'
12380
12381    def to_dict(self):
12382        return {
12383            'ca_cert_path': self.ca_cert_path,
12384            'client_cert_path': self.client_cert_path,
12385            'client_key_path': self.client_key_path,
12386            'id': self.id,
12387            'name': self.name,
12388            'namespace': self.namespace,
12389            'server_address': self.server_address,
12390            'tags': self.tags,
12391        }
12392
12393    @classmethod
12394    def from_dict(cls, d):
12395        return cls(
12396            ca_cert_path=d.get('ca_cert_path'),
12397            client_cert_path=d.get('client_cert_path'),
12398            client_key_path=d.get('client_key_path'),
12399            id=d.get('id'),
12400            name=d.get('name'),
12401            namespace=d.get('namespace'),
12402            server_address=d.get('server_address'),
12403            tags=d.get('tags'),
12404        )
12405
12406
12407class VaultTokenStore:
12408    __slots__ = [
12409        'id',
12410        'name',
12411        'namespace',
12412        'server_address',
12413        'tags',
12414    ]
12415
12416    def __init__(
12417        self,
12418        id=None,
12419        name=None,
12420        namespace=None,
12421        server_address=None,
12422        tags=None,
12423    ):
12424        self.id = id if id is not None else ''
12425        '''
12426         Unique identifier of the SecretStore.
12427        '''
12428        self.name = name if name is not None else ''
12429        '''
12430         Unique human-readable name of the SecretStore.
12431        '''
12432        self.namespace = namespace if namespace is not None else ''
12433        self.server_address = server_address if server_address is not None else ''
12434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12435        '''
12436         Tags is a map of key, value pairs.
12437        '''
12438
12439    def __repr__(self):
12440        return '<sdm.VaultTokenStore ' + \
12441            'id: ' + repr(self.id) + ' ' +\
12442            'name: ' + repr(self.name) + ' ' +\
12443            'namespace: ' + repr(self.namespace) + ' ' +\
12444            'server_address: ' + repr(self.server_address) + ' ' +\
12445            'tags: ' + repr(self.tags) + ' ' +\
12446            '>'
12447
12448    def to_dict(self):
12449        return {
12450            'id': self.id,
12451            'name': self.name,
12452            'namespace': self.namespace,
12453            'server_address': self.server_address,
12454            'tags': self.tags,
12455        }
12456
12457    @classmethod
12458    def from_dict(cls, d):
12459        return cls(
12460            id=d.get('id'),
12461            name=d.get('name'),
12462            namespace=d.get('namespace'),
12463            server_address=d.get('server_address'),
12464            tags=d.get('tags'),
12465        )
12466
12467
12468def _porcelain_zero_value_tags():
12469    return {}
12470
12471
12472def _porcelain_zero_value_access_rules():
12473    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSConsole:
785class AWSConsole:
786    '''
787    AWSConsole is currently unstable, and its API may change, or it may be removed,
788    without a major version bump.
789    '''
790    __slots__ = [
791        'bind_interface',
792        'egress_filter',
793        'enable_env_variables',
794        'healthy',
795        'id',
796        'name',
797        'port_override',
798        'region',
799        'remote_identity_group_id',
800        'remote_identity_healthcheck_username',
801        'role_arn',
802        'role_external_id',
803        'secret_store_id',
804        'session_expiry',
805        'subdomain',
806        'tags',
807    ]
808
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
865
866    def __repr__(self):
867        return '<sdm.AWSConsole ' + \
868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
870            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
871            'healthy: ' + repr(self.healthy) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'name: ' + repr(self.name) + ' ' +\
874            'port_override: ' + repr(self.port_override) + ' ' +\
875            'region: ' + repr(self.region) + ' ' +\
876            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
877            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
878            'role_arn: ' + repr(self.role_arn) + ' ' +\
879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
881            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
882            'subdomain: ' + repr(self.subdomain) + ' ' +\
883            'tags: ' + repr(self.tags) + ' ' +\
884            '>'
885
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
906
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )

AWSConsole is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsole( bind_interface=None, egress_filter=None, enable_env_variables=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

enable_env_variables
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
@classmethod
def from_dict(cls, d)
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )
class AWSConsoleStaticKeyPair:
 930class AWSConsoleStaticKeyPair:
 931    '''
 932    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
 933    without a major version bump.
 934    '''
 935    __slots__ = [
 936        'access_key',
 937        'bind_interface',
 938        'egress_filter',
 939        'healthy',
 940        'id',
 941        'name',
 942        'port_override',
 943        'region',
 944        'remote_identity_group_id',
 945        'remote_identity_healthcheck_username',
 946        'role_arn',
 947        'role_external_id',
 948        'secret_access_key',
 949        'secret_store_id',
 950        'session_expiry',
 951        'subdomain',
 952        'tags',
 953    ]
 954
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
1013
1014    def __repr__(self):
1015        return '<sdm.AWSConsoleStaticKeyPair ' + \
1016            'access_key: ' + repr(self.access_key) + ' ' +\
1017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1019            'healthy: ' + repr(self.healthy) + ' ' +\
1020            'id: ' + repr(self.id) + ' ' +\
1021            'name: ' + repr(self.name) + ' ' +\
1022            'port_override: ' + repr(self.port_override) + ' ' +\
1023            'region: ' + repr(self.region) + ' ' +\
1024            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1025            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1026            'role_arn: ' + repr(self.role_arn) + ' ' +\
1027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1030            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
1031            'subdomain: ' + repr(self.subdomain) + ' ' +\
1032            'tags: ' + repr(self.tags) + ' ' +\
1033            '>'
1034
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
1056
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )

AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsoleStaticKeyPair( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
@classmethod
def from_dict(cls, d)
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )
class AWSStore:
1081class AWSStore:
1082    __slots__ = [
1083        'id',
1084        'name',
1085        'region',
1086        'tags',
1087    ]
1088
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AWSStore ' + \
1112            'id: ' + repr(self.id) + ' ' +\
1113            'name: ' + repr(self.name) + ' ' +\
1114            'region: ' + repr(self.region) + ' ' +\
1115            'tags: ' + repr(self.tags) + ' ' +\
1116            '>'
1117
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
1125
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
AWSStore(id=None, name=None, region=None, tags=None)
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
@classmethod
def from_dict(cls, d)
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
class AccountAttachment:
1136class AccountAttachment:
1137    '''
1138         AccountAttachments assign an account to a role.
1139    '''
1140    __slots__ = [
1141        'account_id',
1142        'id',
1143        'role_id',
1144    ]
1145
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
1164
1165    def __repr__(self):
1166        return '<sdm.AccountAttachment ' + \
1167            'account_id: ' + repr(self.account_id) + ' ' +\
1168            'id: ' + repr(self.id) + ' ' +\
1169            'role_id: ' + repr(self.role_id) + ' ' +\
1170            '>'
1171
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
1178
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
@classmethod
def from_dict(cls, d)
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )
class AccountAttachmentCreateResponse:
1188class AccountAttachmentCreateResponse:
1189    '''
1190         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1191    '''
1192    __slots__ = [
1193        'account_attachment',
1194        'meta',
1195        'rate_limit',
1196    ]
1197
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
1216
1217    def __repr__(self):
1218        return '<sdm.AccountAttachmentCreateResponse ' + \
1219            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1220            'meta: ' + repr(self.meta) + ' ' +\
1221            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1222            '>'
1223
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
1230
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
@classmethod
def from_dict(cls, d)
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )
class AccountAttachmentDeleteResponse:
1240class AccountAttachmentDeleteResponse:
1241    '''
1242         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1243    '''
1244    __slots__ = [
1245        'meta',
1246        'rate_limit',
1247    ]
1248
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
1262
1263    def __repr__(self):
1264        return '<sdm.AccountAttachmentDeleteResponse ' + \
1265            'meta: ' + repr(self.meta) + ' ' +\
1266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1267            '>'
1268
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
1274
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
@classmethod
def from_dict(cls, d)
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )
class AccountAttachmentGetResponse:
1283class AccountAttachmentGetResponse:
1284    '''
1285         AccountAttachmentGetResponse returns a requested AccountAttachment.
1286    '''
1287    __slots__ = [
1288        'account_attachment',
1289        'meta',
1290        'rate_limit',
1291    ]
1292
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
1311
1312    def __repr__(self):
1313        return '<sdm.AccountAttachmentGetResponse ' + \
1314            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1315            'meta: ' + repr(self.meta) + ' ' +\
1316            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1317            '>'
1318
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
1325
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
@classmethod
def from_dict(cls, d)
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )
class AccountCreateResponse:
1335class AccountCreateResponse:
1336    '''
1337         AccountCreateResponse reports how the Accounts were created in the system.
1338    '''
1339    __slots__ = [
1340        'account',
1341        'meta',
1342        'rate_limit',
1343        'token',
1344    ]
1345
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
1370
1371    def __repr__(self):
1372        return '<sdm.AccountCreateResponse ' + \
1373            'account: ' + repr(self.account) + ' ' +\
1374            'meta: ' + repr(self.meta) + ' ' +\
1375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1376            'token: ' + repr(self.token) + ' ' +\
1377            '>'
1378
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
1386
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
@classmethod
def from_dict(cls, d)
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )
class AccountDeleteResponse:
1397class AccountDeleteResponse:
1398    '''
1399         AccountDeleteResponse returns information about a Account that was deleted.
1400    '''
1401    __slots__ = [
1402        'meta',
1403        'rate_limit',
1404    ]
1405
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
1419
1420    def __repr__(self):
1421        return '<sdm.AccountDeleteResponse ' + \
1422            'meta: ' + repr(self.meta) + ' ' +\
1423            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1424            '>'
1425
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
1431
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
@classmethod
def from_dict(cls, d)
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )
class AccountGetResponse:
1440class AccountGetResponse:
1441    '''
1442         AccountGetResponse returns a requested Account.
1443    '''
1444    __slots__ = [
1445        'account',
1446        'meta',
1447        'rate_limit',
1448    ]
1449
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGetResponse ' + \
1471            'account: ' + repr(self.account) + ' ' +\
1472            'meta: ' + repr(self.meta) + ' ' +\
1473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1474            '>'
1475
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
1482
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
@classmethod
def from_dict(cls, d)
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )
class AccountGrant:
1492class AccountGrant:
1493    '''
1494         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1495    '''
1496    __slots__ = [
1497        'account_id',
1498        'id',
1499        'resource_id',
1500        'start_from',
1501        'valid_until',
1502    ]
1503
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
1532
1533    def __repr__(self):
1534        return '<sdm.AccountGrant ' + \
1535            'account_id: ' + repr(self.account_id) + ' ' +\
1536            'id: ' + repr(self.id) + ' ' +\
1537            'resource_id: ' + repr(self.resource_id) + ' ' +\
1538            'start_from: ' + repr(self.start_from) + ' ' +\
1539            'valid_until: ' + repr(self.valid_until) + ' ' +\
1540            '>'
1541
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
1550
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
@classmethod
def from_dict(cls, d)
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )
class AccountGrantCreateResponse:
1562class AccountGrantCreateResponse:
1563    '''
1564         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1565    '''
1566    __slots__ = [
1567        'account_grant',
1568        'meta',
1569        'rate_limit',
1570    ]
1571
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
1590
1591    def __repr__(self):
1592        return '<sdm.AccountGrantCreateResponse ' + \
1593            'account_grant: ' + repr(self.account_grant) + ' ' +\
1594            'meta: ' + repr(self.meta) + ' ' +\
1595            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1596            '>'
1597
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
1604
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
@classmethod
def from_dict(cls, d)
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )
class AccountGrantDeleteResponse:
1614class AccountGrantDeleteResponse:
1615    '''
1616         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1617    '''
1618    __slots__ = [
1619        'meta',
1620        'rate_limit',
1621    ]
1622
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
1636
1637    def __repr__(self):
1638        return '<sdm.AccountGrantDeleteResponse ' + \
1639            'meta: ' + repr(self.meta) + ' ' +\
1640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1641            '>'
1642
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
1648
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
@classmethod
def from_dict(cls, d)
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )
class AccountGrantGetResponse:
1657class AccountGrantGetResponse:
1658    '''
1659         AccountGrantGetResponse returns a requested AccountGrant.
1660    '''
1661    __slots__ = [
1662        'account_grant',
1663        'meta',
1664        'rate_limit',
1665    ]
1666
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
1685
1686    def __repr__(self):
1687        return '<sdm.AccountGrantGetResponse ' + \
1688            'account_grant: ' + repr(self.account_grant) + ' ' +\
1689            'meta: ' + repr(self.meta) + ' ' +\
1690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1691            '>'
1692
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
1699
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
@classmethod
def from_dict(cls, d)
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )
class AccountUpdateResponse:
1709class AccountUpdateResponse:
1710    '''
1711         AccountUpdateResponse returns the fields of a Account after it has been updated by
1712     a AccountUpdateRequest.
1713    '''
1714    __slots__ = [
1715        'account',
1716        'meta',
1717        'rate_limit',
1718    ]
1719
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
1738
1739    def __repr__(self):
1740        return '<sdm.AccountUpdateResponse ' + \
1741            'account: ' + repr(self.account) + ' ' +\
1742            'meta: ' + repr(self.meta) + ' ' +\
1743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1744            '>'
1745
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
@classmethod
def from_dict(cls, d)
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )
class AmazonEKS:
1762class AmazonEKS:
1763    __slots__ = [
1764        'access_key',
1765        'bind_interface',
1766        'certificate_authority',
1767        'cluster_name',
1768        'egress_filter',
1769        'endpoint',
1770        'healthcheck_namespace',
1771        'healthy',
1772        'id',
1773        'name',
1774        'region',
1775        'remote_identity_group_id',
1776        'remote_identity_healthcheck_username',
1777        'role_arn',
1778        'role_external_id',
1779        'secret_access_key',
1780        'secret_store_id',
1781        'tags',
1782    ]
1783
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
1847
1848    def __repr__(self):
1849        return '<sdm.AmazonEKS ' + \
1850            'access_key: ' + repr(self.access_key) + ' ' +\
1851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1852            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1853            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1855            'endpoint: ' + repr(self.endpoint) + ' ' +\
1856            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1857            'healthy: ' + repr(self.healthy) + ' ' +\
1858            'id: ' + repr(self.id) + ' ' +\
1859            'name: ' + repr(self.name) + ' ' +\
1860            'region: ' + repr(self.region) + ' ' +\
1861            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1862            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1863            'role_arn: ' + repr(self.role_arn) + ' ' +\
1864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1867            'tags: ' + repr(self.tags) + ' ' +\
1868            '>'
1869
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
1892
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
@classmethod
def from_dict(cls, d)
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
class AmazonEKSUserImpersonation:
1918class AmazonEKSUserImpersonation:
1919    __slots__ = [
1920        'access_key',
1921        'bind_interface',
1922        'certificate_authority',
1923        'cluster_name',
1924        'egress_filter',
1925        'endpoint',
1926        'healthcheck_namespace',
1927        'healthy',
1928        'id',
1929        'name',
1930        'region',
1931        'role_arn',
1932        'role_external_id',
1933        'secret_access_key',
1934        'secret_store_id',
1935        'tags',
1936    ]
1937
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
1997
1998    def __repr__(self):
1999        return '<sdm.AmazonEKSUserImpersonation ' + \
2000            'access_key: ' + repr(self.access_key) + ' ' +\
2001            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2002            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2003            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2005            'endpoint: ' + repr(self.endpoint) + ' ' +\
2006            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2007            'healthy: ' + repr(self.healthy) + ' ' +\
2008            'id: ' + repr(self.id) + ' ' +\
2009            'name: ' + repr(self.name) + ' ' +\
2010            'region: ' + repr(self.region) + ' ' +\
2011            'role_arn: ' + repr(self.role_arn) + ' ' +\
2012            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2013            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2014            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2015            'tags: ' + repr(self.tags) + ' ' +\
2016            '>'
2017
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
2037
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
@classmethod
def from_dict(cls, d)
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
class AmazonES:
2060class AmazonES:
2061    __slots__ = [
2062        'access_key',
2063        'bind_interface',
2064        'egress_filter',
2065        'endpoint',
2066        'healthy',
2067        'id',
2068        'name',
2069        'port_override',
2070        'region',
2071        'role_arn',
2072        'role_external_id',
2073        'secret_access_key',
2074        'secret_store_id',
2075        'tags',
2076    ]
2077
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
2130
2131    def __repr__(self):
2132        return '<sdm.AmazonES ' + \
2133            'access_key: ' + repr(self.access_key) + ' ' +\
2134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2136            'endpoint: ' + repr(self.endpoint) + ' ' +\
2137            'healthy: ' + repr(self.healthy) + ' ' +\
2138            'id: ' + repr(self.id) + ' ' +\
2139            'name: ' + repr(self.name) + ' ' +\
2140            'port_override: ' + repr(self.port_override) + ' ' +\
2141            'region: ' + repr(self.region) + ' ' +\
2142            'role_arn: ' + repr(self.role_arn) + ' ' +\
2143            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2144            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2146            'tags: ' + repr(self.tags) + ' ' +\
2147            '>'
2148
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
2166
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
@classmethod
def from_dict(cls, d)
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
class AmazonMQAMQP091:
2187class AmazonMQAMQP091:
2188    __slots__ = [
2189        'bind_interface',
2190        'egress_filter',
2191        'healthy',
2192        'hostname',
2193        'id',
2194        'name',
2195        'password',
2196        'port',
2197        'port_override',
2198        'secret_store_id',
2199        'tags',
2200        'tls_required',
2201        'username',
2202    ]
2203
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
2254
2255    def __repr__(self):
2256        return '<sdm.AmazonMQAMQP091 ' + \
2257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2258            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2259            'healthy: ' + repr(self.healthy) + ' ' +\
2260            'hostname: ' + repr(self.hostname) + ' ' +\
2261            'id: ' + repr(self.id) + ' ' +\
2262            'name: ' + repr(self.name) + ' ' +\
2263            'password: ' + repr(self.password) + ' ' +\
2264            'port: ' + repr(self.port) + ' ' +\
2265            'port_override: ' + repr(self.port_override) + ' ' +\
2266            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2267            'tags: ' + repr(self.tags) + ' ' +\
2268            'tls_required: ' + repr(self.tls_required) + ' ' +\
2269            'username: ' + repr(self.username) + ' ' +\
2270            '>'
2271
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
2288
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
@classmethod
def from_dict(cls, d)
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
class Athena:
2308class Athena:
2309    __slots__ = [
2310        'access_key',
2311        'bind_interface',
2312        'egress_filter',
2313        'healthy',
2314        'id',
2315        'name',
2316        'output',
2317        'port_override',
2318        'region',
2319        'role_arn',
2320        'role_external_id',
2321        'secret_access_key',
2322        'secret_store_id',
2323        'tags',
2324    ]
2325
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
2378
2379    def __repr__(self):
2380        return '<sdm.Athena ' + \
2381            'access_key: ' + repr(self.access_key) + ' ' +\
2382            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2384            'healthy: ' + repr(self.healthy) + ' ' +\
2385            'id: ' + repr(self.id) + ' ' +\
2386            'name: ' + repr(self.name) + ' ' +\
2387            'output: ' + repr(self.output) + ' ' +\
2388            'port_override: ' + repr(self.port_override) + ' ' +\
2389            'region: ' + repr(self.region) + ' ' +\
2390            'role_arn: ' + repr(self.role_arn) + ' ' +\
2391            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2392            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2393            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2394            'tags: ' + repr(self.tags) + ' ' +\
2395            '>'
2396
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
2414
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
@classmethod
def from_dict(cls, d)
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
class AuroraMysql:
2435class AuroraMysql:
2436    __slots__ = [
2437        'bind_interface',
2438        'database',
2439        'egress_filter',
2440        'healthy',
2441        'hostname',
2442        'id',
2443        'name',
2444        'password',
2445        'port',
2446        'port_override',
2447        'secret_store_id',
2448        'tags',
2449        'username',
2450    ]
2451
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
2502
2503    def __repr__(self):
2504        return '<sdm.AuroraMysql ' + \
2505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2506            'database: ' + repr(self.database) + ' ' +\
2507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2508            'healthy: ' + repr(self.healthy) + ' ' +\
2509            'hostname: ' + repr(self.hostname) + ' ' +\
2510            'id: ' + repr(self.id) + ' ' +\
2511            'name: ' + repr(self.name) + ' ' +\
2512            'password: ' + repr(self.password) + ' ' +\
2513            'port: ' + repr(self.port) + ' ' +\
2514            'port_override: ' + repr(self.port_override) + ' ' +\
2515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2516            'tags: ' + repr(self.tags) + ' ' +\
2517            'username: ' + repr(self.username) + ' ' +\
2518            '>'
2519
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
2536
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
@classmethod
def from_dict(cls, d)
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
class AuroraPostgres:
2556class AuroraPostgres:
2557    __slots__ = [
2558        'bind_interface',
2559        'database',
2560        'egress_filter',
2561        'healthy',
2562        'hostname',
2563        'id',
2564        'name',
2565        'override_database',
2566        'password',
2567        'port',
2568        'port_override',
2569        'secret_store_id',
2570        'tags',
2571        'username',
2572    ]
2573
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
2626
2627    def __repr__(self):
2628        return '<sdm.AuroraPostgres ' + \
2629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2630            'database: ' + repr(self.database) + ' ' +\
2631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2632            'healthy: ' + repr(self.healthy) + ' ' +\
2633            'hostname: ' + repr(self.hostname) + ' ' +\
2634            'id: ' + repr(self.id) + ' ' +\
2635            'name: ' + repr(self.name) + ' ' +\
2636            'override_database: ' + repr(self.override_database) + ' ' +\
2637            'password: ' + repr(self.password) + ' ' +\
2638            'port: ' + repr(self.port) + ' ' +\
2639            'port_override: ' + repr(self.port_override) + ' ' +\
2640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2641            'tags: ' + repr(self.tags) + ' ' +\
2642            'username: ' + repr(self.username) + ' ' +\
2643            '>'
2644
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
2662
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
@classmethod
def from_dict(cls, d)
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
class Azure:
2683class Azure:
2684    __slots__ = [
2685        'app_id',
2686        'bind_interface',
2687        'egress_filter',
2688        'healthy',
2689        'id',
2690        'name',
2691        'password',
2692        'secret_store_id',
2693        'tags',
2694        'tenant_id',
2695    ]
2696
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
2741
2742    def __repr__(self):
2743        return '<sdm.Azure ' + \
2744            'app_id: ' + repr(self.app_id) + ' ' +\
2745            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2747            'healthy: ' + repr(self.healthy) + ' ' +\
2748            'id: ' + repr(self.id) + ' ' +\
2749            'name: ' + repr(self.name) + ' ' +\
2750            'password: ' + repr(self.password) + ' ' +\
2751            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2752            'tags: ' + repr(self.tags) + ' ' +\
2753            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2754            '>'
2755
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
2769
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
@classmethod
def from_dict(cls, d)
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
class AzureCertificate:
2786class AzureCertificate:
2787    __slots__ = [
2788        'app_id',
2789        'bind_interface',
2790        'client_certificate',
2791        'egress_filter',
2792        'healthy',
2793        'id',
2794        'name',
2795        'secret_store_id',
2796        'tags',
2797        'tenant_id',
2798    ]
2799
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
2844
2845    def __repr__(self):
2846        return '<sdm.AzureCertificate ' + \
2847            'app_id: ' + repr(self.app_id) + ' ' +\
2848            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2849            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2851            'healthy: ' + repr(self.healthy) + ' ' +\
2852            'id: ' + repr(self.id) + ' ' +\
2853            'name: ' + repr(self.name) + ' ' +\
2854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2855            'tags: ' + repr(self.tags) + ' ' +\
2856            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2857            '>'
2858
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
2872
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
@classmethod
def from_dict(cls, d)
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
class AzureMysql:
2889class AzureMysql:
2890    '''
2891    AzureMysql is currently unstable, and its API may change, or it may be removed,
2892    without a major version bump.
2893    '''
2894    __slots__ = [
2895        'bind_interface',
2896        'database',
2897        'egress_filter',
2898        'healthy',
2899        'hostname',
2900        'id',
2901        'name',
2902        'password',
2903        'port',
2904        'port_override',
2905        'secret_store_id',
2906        'tags',
2907        'username',
2908    ]
2909
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
2960
2961    def __repr__(self):
2962        return '<sdm.AzureMysql ' + \
2963            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2964            'database: ' + repr(self.database) + ' ' +\
2965            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2966            'healthy: ' + repr(self.healthy) + ' ' +\
2967            'hostname: ' + repr(self.hostname) + ' ' +\
2968            'id: ' + repr(self.id) + ' ' +\
2969            'name: ' + repr(self.name) + ' ' +\
2970            'password: ' + repr(self.password) + ' ' +\
2971            'port: ' + repr(self.port) + ' ' +\
2972            'port_override: ' + repr(self.port_override) + ' ' +\
2973            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2974            'tags: ' + repr(self.tags) + ' ' +\
2975            'username: ' + repr(self.username) + ' ' +\
2976            '>'
2977
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
2994
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )

AzureMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

AzureMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
@classmethod
def from_dict(cls, d)
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )
class AzurePostgres:
3014class AzurePostgres:
3015    __slots__ = [
3016        'bind_interface',
3017        'database',
3018        'egress_filter',
3019        'healthy',
3020        'hostname',
3021        'id',
3022        'name',
3023        'override_database',
3024        'password',
3025        'port',
3026        'port_override',
3027        'secret_store_id',
3028        'tags',
3029        'username',
3030    ]
3031
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
3084
3085    def __repr__(self):
3086        return '<sdm.AzurePostgres ' + \
3087            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3088            'database: ' + repr(self.database) + ' ' +\
3089            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3090            'healthy: ' + repr(self.healthy) + ' ' +\
3091            'hostname: ' + repr(self.hostname) + ' ' +\
3092            'id: ' + repr(self.id) + ' ' +\
3093            'name: ' + repr(self.name) + ' ' +\
3094            'override_database: ' + repr(self.override_database) + ' ' +\
3095            'password: ' + repr(self.password) + ' ' +\
3096            'port: ' + repr(self.port) + ' ' +\
3097            'port_override: ' + repr(self.port_override) + ' ' +\
3098            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3099            'tags: ' + repr(self.tags) + ' ' +\
3100            'username: ' + repr(self.username) + ' ' +\
3101            '>'
3102
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
3120
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
@classmethod
def from_dict(cls, d)
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
class AzureStore:
3141class AzureStore:
3142    __slots__ = [
3143        'id',
3144        'name',
3145        'tags',
3146        'vault_uri',
3147    ]
3148
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
3169
3170    def __repr__(self):
3171        return '<sdm.AzureStore ' + \
3172            'id: ' + repr(self.id) + ' ' +\
3173            'name: ' + repr(self.name) + ' ' +\
3174            'tags: ' + repr(self.tags) + ' ' +\
3175            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3176            '>'
3177
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
3185
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
@classmethod
def from_dict(cls, d)
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
class BigQuery:
3196class BigQuery:
3197    __slots__ = [
3198        'bind_interface',
3199        'egress_filter',
3200        'endpoint',
3201        'healthy',
3202        'id',
3203        'name',
3204        'port_override',
3205        'private_key',
3206        'project',
3207        'secret_store_id',
3208        'tags',
3209        'username',
3210    ]
3211
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
3260
3261    def __repr__(self):
3262        return '<sdm.BigQuery ' + \
3263            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3264            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3265            'endpoint: ' + repr(self.endpoint) + ' ' +\
3266            'healthy: ' + repr(self.healthy) + ' ' +\
3267            'id: ' + repr(self.id) + ' ' +\
3268            'name: ' + repr(self.name) + ' ' +\
3269            'port_override: ' + repr(self.port_override) + ' ' +\
3270            'private_key: ' + repr(self.private_key) + ' ' +\
3271            'project: ' + repr(self.project) + ' ' +\
3272            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3273            'tags: ' + repr(self.tags) + ' ' +\
3274            'username: ' + repr(self.username) + ' ' +\
3275            '>'
3276
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
3292
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
@classmethod
def from_dict(cls, d)
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
class Cassandra:
3311class Cassandra:
3312    __slots__ = [
3313        'bind_interface',
3314        'egress_filter',
3315        'healthy',
3316        'hostname',
3317        'id',
3318        'name',
3319        'password',
3320        'port',
3321        'port_override',
3322        'secret_store_id',
3323        'tags',
3324        'tls_required',
3325        'username',
3326    ]
3327
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
3378
3379    def __repr__(self):
3380        return '<sdm.Cassandra ' + \
3381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3383            'healthy: ' + repr(self.healthy) + ' ' +\
3384            'hostname: ' + repr(self.hostname) + ' ' +\
3385            'id: ' + repr(self.id) + ' ' +\
3386            'name: ' + repr(self.name) + ' ' +\
3387            'password: ' + repr(self.password) + ' ' +\
3388            'port: ' + repr(self.port) + ' ' +\
3389            'port_override: ' + repr(self.port_override) + ' ' +\
3390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3391            'tags: ' + repr(self.tags) + ' ' +\
3392            'tls_required: ' + repr(self.tls_required) + ' ' +\
3393            'username: ' + repr(self.username) + ' ' +\
3394            '>'
3395
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
3412
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
@classmethod
def from_dict(cls, d)
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
class Citus:
3432class Citus:
3433    __slots__ = [
3434        'bind_interface',
3435        'database',
3436        'egress_filter',
3437        'healthy',
3438        'hostname',
3439        'id',
3440        'name',
3441        'override_database',
3442        'password',
3443        'port',
3444        'port_override',
3445        'secret_store_id',
3446        'tags',
3447        'username',
3448    ]
3449
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
3502
3503    def __repr__(self):
3504        return '<sdm.Citus ' + \
3505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3506            'database: ' + repr(self.database) + ' ' +\
3507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3508            'healthy: ' + repr(self.healthy) + ' ' +\
3509            'hostname: ' + repr(self.hostname) + ' ' +\
3510            'id: ' + repr(self.id) + ' ' +\
3511            'name: ' + repr(self.name) + ' ' +\
3512            'override_database: ' + repr(self.override_database) + ' ' +\
3513            'password: ' + repr(self.password) + ' ' +\
3514            'port: ' + repr(self.port) + ' ' +\
3515            'port_override: ' + repr(self.port_override) + ' ' +\
3516            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3517            'tags: ' + repr(self.tags) + ' ' +\
3518            'username: ' + repr(self.username) + ' ' +\
3519            '>'
3520
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
3538
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
@classmethod
def from_dict(cls, d)
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
class Clustrix:
3559class Clustrix:
3560    __slots__ = [
3561        'bind_interface',
3562        'database',
3563        'egress_filter',
3564        'healthy',
3565        'hostname',
3566        'id',
3567        'name',
3568        'password',
3569        'port',
3570        'port_override',
3571        'secret_store_id',
3572        'tags',
3573        'username',
3574    ]
3575
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
3626
3627    def __repr__(self):
3628        return '<sdm.Clustrix ' + \
3629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3630            'database: ' + repr(self.database) + ' ' +\
3631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3632            'healthy: ' + repr(self.healthy) + ' ' +\
3633            'hostname: ' + repr(self.hostname) + ' ' +\
3634            'id: ' + repr(self.id) + ' ' +\
3635            'name: ' + repr(self.name) + ' ' +\
3636            'password: ' + repr(self.password) + ' ' +\
3637            'port: ' + repr(self.port) + ' ' +\
3638            'port_override: ' + repr(self.port_override) + ' ' +\
3639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3640            'tags: ' + repr(self.tags) + ' ' +\
3641            'username: ' + repr(self.username) + ' ' +\
3642            '>'
3643
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
3660
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
@classmethod
def from_dict(cls, d)
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
class Cockroach:
3680class Cockroach:
3681    __slots__ = [
3682        'bind_interface',
3683        'database',
3684        'egress_filter',
3685        'healthy',
3686        'hostname',
3687        'id',
3688        'name',
3689        'override_database',
3690        'password',
3691        'port',
3692        'port_override',
3693        'secret_store_id',
3694        'tags',
3695        'username',
3696    ]
3697
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
3750
3751    def __repr__(self):
3752        return '<sdm.Cockroach ' + \
3753            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3754            'database: ' + repr(self.database) + ' ' +\
3755            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3756            'healthy: ' + repr(self.healthy) + ' ' +\
3757            'hostname: ' + repr(self.hostname) + ' ' +\
3758            'id: ' + repr(self.id) + ' ' +\
3759            'name: ' + repr(self.name) + ' ' +\
3760            'override_database: ' + repr(self.override_database) + ' ' +\
3761            'password: ' + repr(self.password) + ' ' +\
3762            'port: ' + repr(self.port) + ' ' +\
3763            'port_override: ' + repr(self.port_override) + ' ' +\
3764            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3765            'tags: ' + repr(self.tags) + ' ' +\
3766            'username: ' + repr(self.username) + ' ' +\
3767            '>'
3768
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
3786
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
@classmethod
def from_dict(cls, d)
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
class ControlPanelGetSSHCAPublicKeyResponse:
3807class ControlPanelGetSSHCAPublicKeyResponse:
3808    '''
3809         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3810     organization's SSH Certificate Authority public key.
3811    '''
3812    __slots__ = [
3813        'meta',
3814        'public_key',
3815        'rate_limit',
3816    ]
3817
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
3837
3838    def __repr__(self):
3839        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3840            'meta: ' + repr(self.meta) + ' ' +\
3841            'public_key: ' + repr(self.public_key) + ' ' +\
3842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3843            '>'
3844
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
3851
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
@classmethod
def from_dict(cls, d)
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )
class ControlPanelVerifyJWTResponse:
3861class ControlPanelVerifyJWTResponse:
3862    '''
3863         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3864    '''
3865    __slots__ = [
3866        'meta',
3867        'rate_limit',
3868        'valid',
3869    ]
3870
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
3889
3890    def __repr__(self):
3891        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3892            'meta: ' + repr(self.meta) + ' ' +\
3893            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3894            'valid: ' + repr(self.valid) + ' ' +\
3895            '>'
3896
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
3903
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
@classmethod
def from_dict(cls, d)
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )
class CreateResponseMetadata:
3913class CreateResponseMetadata:
3914    '''
3915         CreateResponseMetadata is reserved for future use.
3916    '''
3917    __slots__ = []
3918
3919    def __init__(self, ):
3920        pass
3921
3922    def __repr__(self):
3923        return '<sdm.CreateResponseMetadata ' + \
3924            '>'
3925
3926    def to_dict(self):
3927        return {}
3928
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3919    def __init__(self, ):
3920        pass
def to_dict(self)
3926    def to_dict(self):
3927        return {}
@classmethod
def from_dict(cls, d)
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()
class CyberarkConjurStore:
3934class CyberarkConjurStore:
3935    '''
3936    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
3937    without a major version bump.
3938    '''
3939    __slots__ = [
3940        'appurl',
3941        'id',
3942        'name',
3943        'tags',
3944    ]
3945
3946    def __init__(
3947        self,
3948        appurl=None,
3949        id=None,
3950        name=None,
3951        tags=None,
3952    ):
3953        self.appurl = appurl if appurl is not None else ''
3954        self.id = id if id is not None else ''
3955        '''
3956         Unique identifier of the SecretStore.
3957        '''
3958        self.name = name if name is not None else ''
3959        '''
3960         Unique human-readable name of the SecretStore.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966
3967    def __repr__(self):
3968        return '<sdm.CyberarkConjurStore ' + \
3969            'appurl: ' + repr(self.appurl) + ' ' +\
3970            'id: ' + repr(self.id) + ' ' +\
3971            'name: ' + repr(self.name) + ' ' +\
3972            'tags: ' + repr(self.tags) + ' ' +\
3973            '>'
3974
3975    def to_dict(self):
3976        return {
3977            'appurl': self.appurl,
3978            'id': self.id,
3979            'name': self.name,
3980            'tags': self.tags,
3981        }
3982
3983    @classmethod
3984    def from_dict(cls, d):
3985        return cls(
3986            appurl=d.get('appurl'),
3987            id=d.get('id'),
3988            name=d.get('name'),
3989            tags=d.get('tags'),
3990        )

CyberarkConjurStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkConjurStore(appurl=None, id=None, name=None, tags=None)
3946    def __init__(
3947        self,
3948        appurl=None,
3949        id=None,
3950        name=None,
3951        tags=None,
3952    ):
3953        self.appurl = appurl if appurl is not None else ''
3954        self.id = id if id is not None else ''
3955        '''
3956         Unique identifier of the SecretStore.
3957        '''
3958        self.name = name if name is not None else ''
3959        '''
3960         Unique human-readable name of the SecretStore.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3975    def to_dict(self):
3976        return {
3977            'appurl': self.appurl,
3978            'id': self.id,
3979            'name': self.name,
3980            'tags': self.tags,
3981        }
@classmethod
def from_dict(cls, d)
3983    @classmethod
3984    def from_dict(cls, d):
3985        return cls(
3986            appurl=d.get('appurl'),
3987            id=d.get('id'),
3988            name=d.get('name'),
3989            tags=d.get('tags'),
3990        )
class CyberarkPAMExperimentalStore:
3993class CyberarkPAMExperimentalStore:
3994    '''
3995    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
3996    without a major version bump.
3997    '''
3998    __slots__ = [
3999        'appurl',
4000        'id',
4001        'name',
4002        'tags',
4003    ]
4004
4005    def __init__(
4006        self,
4007        appurl=None,
4008        id=None,
4009        name=None,
4010        tags=None,
4011    ):
4012        self.appurl = appurl if appurl is not None else ''
4013        self.id = id if id is not None else ''
4014        '''
4015         Unique identifier of the SecretStore.
4016        '''
4017        self.name = name if name is not None else ''
4018        '''
4019         Unique human-readable name of the SecretStore.
4020        '''
4021        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4022        '''
4023         Tags is a map of key, value pairs.
4024        '''
4025
4026    def __repr__(self):
4027        return '<sdm.CyberarkPAMExperimentalStore ' + \
4028            'appurl: ' + repr(self.appurl) + ' ' +\
4029            'id: ' + repr(self.id) + ' ' +\
4030            'name: ' + repr(self.name) + ' ' +\
4031            'tags: ' + repr(self.tags) + ' ' +\
4032            '>'
4033
4034    def to_dict(self):
4035        return {
4036            'appurl': self.appurl,
4037            'id': self.id,
4038            'name': self.name,
4039            'tags': self.tags,
4040        }
4041
4042    @classmethod
4043    def from_dict(cls, d):
4044        return cls(
4045            appurl=d.get('appurl'),
4046            id=d.get('id'),
4047            name=d.get('name'),
4048            tags=d.get('tags'),
4049        )

CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkPAMExperimentalStore(appurl=None, id=None, name=None, tags=None)
4005    def __init__(
4006        self,
4007        appurl=None,
4008        id=None,
4009        name=None,
4010        tags=None,
4011    ):
4012        self.appurl = appurl if appurl is not None else ''
4013        self.id = id if id is not None else ''
4014        '''
4015         Unique identifier of the SecretStore.
4016        '''
4017        self.name = name if name is not None else ''
4018        '''
4019         Unique human-readable name of the SecretStore.
4020        '''
4021        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4022        '''
4023         Tags is a map of key, value pairs.
4024        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4034    def to_dict(self):
4035        return {
4036            'appurl': self.appurl,
4037            'id': self.id,
4038            'name': self.name,
4039            'tags': self.tags,
4040        }
@classmethod
def from_dict(cls, d)
4042    @classmethod
4043    def from_dict(cls, d):
4044        return cls(
4045            appurl=d.get('appurl'),
4046            id=d.get('id'),
4047            name=d.get('name'),
4048            tags=d.get('tags'),
4049        )
class DB2I:
4052class DB2I:
4053    __slots__ = [
4054        'bind_interface',
4055        'egress_filter',
4056        'healthy',
4057        'hostname',
4058        'id',
4059        'name',
4060        'password',
4061        'port',
4062        'port_override',
4063        'secret_store_id',
4064        'tags',
4065        'tls_required',
4066        'username',
4067    ]
4068
4069    def __init__(
4070        self,
4071        bind_interface=None,
4072        egress_filter=None,
4073        healthy=None,
4074        hostname=None,
4075        id=None,
4076        name=None,
4077        password=None,
4078        port=None,
4079        port_override=None,
4080        secret_store_id=None,
4081        tags=None,
4082        tls_required=None,
4083        username=None,
4084    ):
4085        self.bind_interface = bind_interface if bind_interface is not None else ''
4086        '''
4087         Bind interface
4088        '''
4089        self.egress_filter = egress_filter if egress_filter is not None else ''
4090        '''
4091         A filter applied to the routing logic to pin datasource to nodes.
4092        '''
4093        self.healthy = healthy if healthy is not None else False
4094        '''
4095         True if the datasource is reachable and the credentials are valid.
4096        '''
4097        self.hostname = hostname if hostname is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the Resource.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the Resource.
4105        '''
4106        self.password = password if password is not None else ''
4107        self.port = port if port is not None else 0
4108        self.port_override = port_override if port_override is not None else 0
4109        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4110        '''
4111         ID of the secret store containing credentials for this resource, if any.
4112        '''
4113        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4114        '''
4115         Tags is a map of key, value pairs.
4116        '''
4117        self.tls_required = tls_required if tls_required is not None else False
4118        self.username = username if username is not None else ''
4119
4120    def __repr__(self):
4121        return '<sdm.DB2I ' + \
4122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4123            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4124            'healthy: ' + repr(self.healthy) + ' ' +\
4125            'hostname: ' + repr(self.hostname) + ' ' +\
4126            'id: ' + repr(self.id) + ' ' +\
4127            'name: ' + repr(self.name) + ' ' +\
4128            'password: ' + repr(self.password) + ' ' +\
4129            'port: ' + repr(self.port) + ' ' +\
4130            'port_override: ' + repr(self.port_override) + ' ' +\
4131            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4132            'tags: ' + repr(self.tags) + ' ' +\
4133            'tls_required: ' + repr(self.tls_required) + ' ' +\
4134            'username: ' + repr(self.username) + ' ' +\
4135            '>'
4136
4137    def to_dict(self):
4138        return {
4139            'bind_interface': self.bind_interface,
4140            'egress_filter': self.egress_filter,
4141            'healthy': self.healthy,
4142            'hostname': self.hostname,
4143            'id': self.id,
4144            'name': self.name,
4145            'password': self.password,
4146            'port': self.port,
4147            'port_override': self.port_override,
4148            'secret_store_id': self.secret_store_id,
4149            'tags': self.tags,
4150            'tls_required': self.tls_required,
4151            'username': self.username,
4152        }
4153
4154    @classmethod
4155    def from_dict(cls, d):
4156        return cls(
4157            bind_interface=d.get('bind_interface'),
4158            egress_filter=d.get('egress_filter'),
4159            healthy=d.get('healthy'),
4160            hostname=d.get('hostname'),
4161            id=d.get('id'),
4162            name=d.get('name'),
4163            password=d.get('password'),
4164            port=d.get('port'),
4165            port_override=d.get('port_override'),
4166            secret_store_id=d.get('secret_store_id'),
4167            tags=d.get('tags'),
4168            tls_required=d.get('tls_required'),
4169            username=d.get('username'),
4170        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4069    def __init__(
4070        self,
4071        bind_interface=None,
4072        egress_filter=None,
4073        healthy=None,
4074        hostname=None,
4075        id=None,
4076        name=None,
4077        password=None,
4078        port=None,
4079        port_override=None,
4080        secret_store_id=None,
4081        tags=None,
4082        tls_required=None,
4083        username=None,
4084    ):
4085        self.bind_interface = bind_interface if bind_interface is not None else ''
4086        '''
4087         Bind interface
4088        '''
4089        self.egress_filter = egress_filter if egress_filter is not None else ''
4090        '''
4091         A filter applied to the routing logic to pin datasource to nodes.
4092        '''
4093        self.healthy = healthy if healthy is not None else False
4094        '''
4095         True if the datasource is reachable and the credentials are valid.
4096        '''
4097        self.hostname = hostname if hostname is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the Resource.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the Resource.
4105        '''
4106        self.password = password if password is not None else ''
4107        self.port = port if port is not None else 0
4108        self.port_override = port_override if port_override is not None else 0
4109        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4110        '''
4111         ID of the secret store containing credentials for this resource, if any.
4112        '''
4113        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4114        '''
4115         Tags is a map of key, value pairs.
4116        '''
4117        self.tls_required = tls_required if tls_required is not None else False
4118        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4137    def to_dict(self):
4138        return {
4139            'bind_interface': self.bind_interface,
4140            'egress_filter': self.egress_filter,
4141            'healthy': self.healthy,
4142            'hostname': self.hostname,
4143            'id': self.id,
4144            'name': self.name,
4145            'password': self.password,
4146            'port': self.port,
4147            'port_override': self.port_override,
4148            'secret_store_id': self.secret_store_id,
4149            'tags': self.tags,
4150            'tls_required': self.tls_required,
4151            'username': self.username,
4152        }
@classmethod
def from_dict(cls, d)
4154    @classmethod
4155    def from_dict(cls, d):
4156        return cls(
4157            bind_interface=d.get('bind_interface'),
4158            egress_filter=d.get('egress_filter'),
4159            healthy=d.get('healthy'),
4160            hostname=d.get('hostname'),
4161            id=d.get('id'),
4162            name=d.get('name'),
4163            password=d.get('password'),
4164            port=d.get('port'),
4165            port_override=d.get('port_override'),
4166            secret_store_id=d.get('secret_store_id'),
4167            tags=d.get('tags'),
4168            tls_required=d.get('tls_required'),
4169            username=d.get('username'),
4170        )
class DB2LUW:
4173class DB2LUW:
4174    __slots__ = [
4175        'bind_interface',
4176        'database',
4177        'egress_filter',
4178        'healthy',
4179        'hostname',
4180        'id',
4181        'name',
4182        'password',
4183        'port',
4184        'port_override',
4185        'secret_store_id',
4186        'tags',
4187        'username',
4188    ]
4189
4190    def __init__(
4191        self,
4192        bind_interface=None,
4193        database=None,
4194        egress_filter=None,
4195        healthy=None,
4196        hostname=None,
4197        id=None,
4198        name=None,
4199        password=None,
4200        port=None,
4201        port_override=None,
4202        secret_store_id=None,
4203        tags=None,
4204        username=None,
4205    ):
4206        self.bind_interface = bind_interface if bind_interface is not None else ''
4207        '''
4208         Bind interface
4209        '''
4210        self.database = database if database is not None else ''
4211        self.egress_filter = egress_filter if egress_filter is not None else ''
4212        '''
4213         A filter applied to the routing logic to pin datasource to nodes.
4214        '''
4215        self.healthy = healthy if healthy is not None else False
4216        '''
4217         True if the datasource is reachable and the credentials are valid.
4218        '''
4219        self.hostname = hostname if hostname is not None else ''
4220        self.id = id if id is not None else ''
4221        '''
4222         Unique identifier of the Resource.
4223        '''
4224        self.name = name if name is not None else ''
4225        '''
4226         Unique human-readable name of the Resource.
4227        '''
4228        self.password = password if password is not None else ''
4229        self.port = port if port is not None else 0
4230        self.port_override = port_override if port_override is not None else 0
4231        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4232        '''
4233         ID of the secret store containing credentials for this resource, if any.
4234        '''
4235        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4236        '''
4237         Tags is a map of key, value pairs.
4238        '''
4239        self.username = username if username is not None else ''
4240
4241    def __repr__(self):
4242        return '<sdm.DB2LUW ' + \
4243            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4244            'database: ' + repr(self.database) + ' ' +\
4245            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4246            'healthy: ' + repr(self.healthy) + ' ' +\
4247            'hostname: ' + repr(self.hostname) + ' ' +\
4248            'id: ' + repr(self.id) + ' ' +\
4249            'name: ' + repr(self.name) + ' ' +\
4250            'password: ' + repr(self.password) + ' ' +\
4251            'port: ' + repr(self.port) + ' ' +\
4252            'port_override: ' + repr(self.port_override) + ' ' +\
4253            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4254            'tags: ' + repr(self.tags) + ' ' +\
4255            'username: ' + repr(self.username) + ' ' +\
4256            '>'
4257
4258    def to_dict(self):
4259        return {
4260            'bind_interface': self.bind_interface,
4261            'database': self.database,
4262            'egress_filter': self.egress_filter,
4263            'healthy': self.healthy,
4264            'hostname': self.hostname,
4265            'id': self.id,
4266            'name': self.name,
4267            'password': self.password,
4268            'port': self.port,
4269            'port_override': self.port_override,
4270            'secret_store_id': self.secret_store_id,
4271            'tags': self.tags,
4272            'username': self.username,
4273        }
4274
4275    @classmethod
4276    def from_dict(cls, d):
4277        return cls(
4278            bind_interface=d.get('bind_interface'),
4279            database=d.get('database'),
4280            egress_filter=d.get('egress_filter'),
4281            healthy=d.get('healthy'),
4282            hostname=d.get('hostname'),
4283            id=d.get('id'),
4284            name=d.get('name'),
4285            password=d.get('password'),
4286            port=d.get('port'),
4287            port_override=d.get('port_override'),
4288            secret_store_id=d.get('secret_store_id'),
4289            tags=d.get('tags'),
4290            username=d.get('username'),
4291        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4190    def __init__(
4191        self,
4192        bind_interface=None,
4193        database=None,
4194        egress_filter=None,
4195        healthy=None,
4196        hostname=None,
4197        id=None,
4198        name=None,
4199        password=None,
4200        port=None,
4201        port_override=None,
4202        secret_store_id=None,
4203        tags=None,
4204        username=None,
4205    ):
4206        self.bind_interface = bind_interface if bind_interface is not None else ''
4207        '''
4208         Bind interface
4209        '''
4210        self.database = database if database is not None else ''
4211        self.egress_filter = egress_filter if egress_filter is not None else ''
4212        '''
4213         A filter applied to the routing logic to pin datasource to nodes.
4214        '''
4215        self.healthy = healthy if healthy is not None else False
4216        '''
4217         True if the datasource is reachable and the credentials are valid.
4218        '''
4219        self.hostname = hostname if hostname is not None else ''
4220        self.id = id if id is not None else ''
4221        '''
4222         Unique identifier of the Resource.
4223        '''
4224        self.name = name if name is not None else ''
4225        '''
4226         Unique human-readable name of the Resource.
4227        '''
4228        self.password = password if password is not None else ''
4229        self.port = port if port is not None else 0
4230        self.port_override = port_override if port_override is not None else 0
4231        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4232        '''
4233         ID of the secret store containing credentials for this resource, if any.
4234        '''
4235        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4236        '''
4237         Tags is a map of key, value pairs.
4238        '''
4239        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4258    def to_dict(self):
4259        return {
4260            'bind_interface': self.bind_interface,
4261            'database': self.database,
4262            'egress_filter': self.egress_filter,
4263            'healthy': self.healthy,
4264            'hostname': self.hostname,
4265            'id': self.id,
4266            'name': self.name,
4267            'password': self.password,
4268            'port': self.port,
4269            'port_override': self.port_override,
4270            'secret_store_id': self.secret_store_id,
4271            'tags': self.tags,
4272            'username': self.username,
4273        }
@classmethod
def from_dict(cls, d)
4275    @classmethod
4276    def from_dict(cls, d):
4277        return cls(
4278            bind_interface=d.get('bind_interface'),
4279            database=d.get('database'),
4280            egress_filter=d.get('egress_filter'),
4281            healthy=d.get('healthy'),
4282            hostname=d.get('hostname'),
4283            id=d.get('id'),
4284            name=d.get('name'),
4285            password=d.get('password'),
4286            port=d.get('port'),
4287            port_override=d.get('port_override'),
4288            secret_store_id=d.get('secret_store_id'),
4289            tags=d.get('tags'),
4290            username=d.get('username'),
4291        )
class DeleteResponseMetadata:
4294class DeleteResponseMetadata:
4295    '''
4296         DeleteResponseMetadata is reserved for future use.
4297    '''
4298    __slots__ = []
4299
4300    def __init__(self, ):
4301        pass
4302
4303    def __repr__(self):
4304        return '<sdm.DeleteResponseMetadata ' + \
4305            '>'
4306
4307    def to_dict(self):
4308        return {}
4309
4310    @classmethod
4311    def from_dict(cls, d):
4312        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4300    def __init__(self, ):
4301        pass
def to_dict(self)
4307    def to_dict(self):
4308        return {}
@classmethod
def from_dict(cls, d)
4310    @classmethod
4311    def from_dict(cls, d):
4312        return cls()
class DelineaStore:
4315class DelineaStore:
4316    '''
4317    DelineaStore is currently unstable, and its API may change, or it may be removed,
4318    without a major version bump.
4319    '''
4320    __slots__ = [
4321        'id',
4322        'name',
4323        'server_url',
4324        'tags',
4325        'tenant_name',
4326    ]
4327
4328    def __init__(
4329        self,
4330        id=None,
4331        name=None,
4332        server_url=None,
4333        tags=None,
4334        tenant_name=None,
4335    ):
4336        self.id = id if id is not None else ''
4337        '''
4338         Unique identifier of the SecretStore.
4339        '''
4340        self.name = name if name is not None else ''
4341        '''
4342         Unique human-readable name of the SecretStore.
4343        '''
4344        self.server_url = server_url if server_url is not None else ''
4345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4346        '''
4347         Tags is a map of key, value pairs.
4348        '''
4349        self.tenant_name = tenant_name if tenant_name is not None else ''
4350
4351    def __repr__(self):
4352        return '<sdm.DelineaStore ' + \
4353            'id: ' + repr(self.id) + ' ' +\
4354            'name: ' + repr(self.name) + ' ' +\
4355            'server_url: ' + repr(self.server_url) + ' ' +\
4356            'tags: ' + repr(self.tags) + ' ' +\
4357            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
4358            '>'
4359
4360    def to_dict(self):
4361        return {
4362            'id': self.id,
4363            'name': self.name,
4364            'server_url': self.server_url,
4365            'tags': self.tags,
4366            'tenant_name': self.tenant_name,
4367        }
4368
4369    @classmethod
4370    def from_dict(cls, d):
4371        return cls(
4372            id=d.get('id'),
4373            name=d.get('name'),
4374            server_url=d.get('server_url'),
4375            tags=d.get('tags'),
4376            tenant_name=d.get('tenant_name'),
4377        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
4328    def __init__(
4329        self,
4330        id=None,
4331        name=None,
4332        server_url=None,
4333        tags=None,
4334        tenant_name=None,
4335    ):
4336        self.id = id if id is not None else ''
4337        '''
4338         Unique identifier of the SecretStore.
4339        '''
4340        self.name = name if name is not None else ''
4341        '''
4342         Unique human-readable name of the SecretStore.
4343        '''
4344        self.server_url = server_url if server_url is not None else ''
4345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4346        '''
4347         Tags is a map of key, value pairs.
4348        '''
4349        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
4360    def to_dict(self):
4361        return {
4362            'id': self.id,
4363            'name': self.name,
4364            'server_url': self.server_url,
4365            'tags': self.tags,
4366            'tenant_name': self.tenant_name,
4367        }
@classmethod
def from_dict(cls, d)
4369    @classmethod
4370    def from_dict(cls, d):
4371        return cls(
4372            id=d.get('id'),
4373            name=d.get('name'),
4374            server_url=d.get('server_url'),
4375            tags=d.get('tags'),
4376            tenant_name=d.get('tenant_name'),
4377        )
class DocumentDBHost:
4380class DocumentDBHost:
4381    __slots__ = [
4382        'auth_database',
4383        'bind_interface',
4384        'egress_filter',
4385        'healthy',
4386        'hostname',
4387        'id',
4388        'name',
4389        'password',
4390        'port',
4391        'port_override',
4392        'secret_store_id',
4393        'tags',
4394        'username',
4395    ]
4396
4397    def __init__(
4398        self,
4399        auth_database=None,
4400        bind_interface=None,
4401        egress_filter=None,
4402        healthy=None,
4403        hostname=None,
4404        id=None,
4405        name=None,
4406        password=None,
4407        port=None,
4408        port_override=None,
4409        secret_store_id=None,
4410        tags=None,
4411        username=None,
4412    ):
4413        self.auth_database = auth_database if auth_database is not None else ''
4414        self.bind_interface = bind_interface if bind_interface is not None else ''
4415        '''
4416         Bind interface
4417        '''
4418        self.egress_filter = egress_filter if egress_filter is not None else ''
4419        '''
4420         A filter applied to the routing logic to pin datasource to nodes.
4421        '''
4422        self.healthy = healthy if healthy is not None else False
4423        '''
4424         True if the datasource is reachable and the credentials are valid.
4425        '''
4426        self.hostname = hostname if hostname is not None else ''
4427        self.id = id if id is not None else ''
4428        '''
4429         Unique identifier of the Resource.
4430        '''
4431        self.name = name if name is not None else ''
4432        '''
4433         Unique human-readable name of the Resource.
4434        '''
4435        self.password = password if password is not None else ''
4436        self.port = port if port is not None else 0
4437        self.port_override = port_override if port_override is not None else 0
4438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4439        '''
4440         ID of the secret store containing credentials for this resource, if any.
4441        '''
4442        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4443        '''
4444         Tags is a map of key, value pairs.
4445        '''
4446        self.username = username if username is not None else ''
4447
4448    def __repr__(self):
4449        return '<sdm.DocumentDBHost ' + \
4450            'auth_database: ' + repr(self.auth_database) + ' ' +\
4451            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4452            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4453            'healthy: ' + repr(self.healthy) + ' ' +\
4454            'hostname: ' + repr(self.hostname) + ' ' +\
4455            'id: ' + repr(self.id) + ' ' +\
4456            'name: ' + repr(self.name) + ' ' +\
4457            'password: ' + repr(self.password) + ' ' +\
4458            'port: ' + repr(self.port) + ' ' +\
4459            'port_override: ' + repr(self.port_override) + ' ' +\
4460            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4461            'tags: ' + repr(self.tags) + ' ' +\
4462            'username: ' + repr(self.username) + ' ' +\
4463            '>'
4464
4465    def to_dict(self):
4466        return {
4467            'auth_database': self.auth_database,
4468            'bind_interface': self.bind_interface,
4469            'egress_filter': self.egress_filter,
4470            'healthy': self.healthy,
4471            'hostname': self.hostname,
4472            'id': self.id,
4473            'name': self.name,
4474            'password': self.password,
4475            'port': self.port,
4476            'port_override': self.port_override,
4477            'secret_store_id': self.secret_store_id,
4478            'tags': self.tags,
4479            'username': self.username,
4480        }
4481
4482    @classmethod
4483    def from_dict(cls, d):
4484        return cls(
4485            auth_database=d.get('auth_database'),
4486            bind_interface=d.get('bind_interface'),
4487            egress_filter=d.get('egress_filter'),
4488            healthy=d.get('healthy'),
4489            hostname=d.get('hostname'),
4490            id=d.get('id'),
4491            name=d.get('name'),
4492            password=d.get('password'),
4493            port=d.get('port'),
4494            port_override=d.get('port_override'),
4495            secret_store_id=d.get('secret_store_id'),
4496            tags=d.get('tags'),
4497            username=d.get('username'),
4498        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4397    def __init__(
4398        self,
4399        auth_database=None,
4400        bind_interface=None,
4401        egress_filter=None,
4402        healthy=None,
4403        hostname=None,
4404        id=None,
4405        name=None,
4406        password=None,
4407        port=None,
4408        port_override=None,
4409        secret_store_id=None,
4410        tags=None,
4411        username=None,
4412    ):
4413        self.auth_database = auth_database if auth_database is not None else ''
4414        self.bind_interface = bind_interface if bind_interface is not None else ''
4415        '''
4416         Bind interface
4417        '''
4418        self.egress_filter = egress_filter if egress_filter is not None else ''
4419        '''
4420         A filter applied to the routing logic to pin datasource to nodes.
4421        '''
4422        self.healthy = healthy if healthy is not None else False
4423        '''
4424         True if the datasource is reachable and the credentials are valid.
4425        '''
4426        self.hostname = hostname if hostname is not None else ''
4427        self.id = id if id is not None else ''
4428        '''
4429         Unique identifier of the Resource.
4430        '''
4431        self.name = name if name is not None else ''
4432        '''
4433         Unique human-readable name of the Resource.
4434        '''
4435        self.password = password if password is not None else ''
4436        self.port = port if port is not None else 0
4437        self.port_override = port_override if port_override is not None else 0
4438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4439        '''
4440         ID of the secret store containing credentials for this resource, if any.
4441        '''
4442        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4443        '''
4444         Tags is a map of key, value pairs.
4445        '''
4446        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4465    def to_dict(self):
4466        return {
4467            'auth_database': self.auth_database,
4468            'bind_interface': self.bind_interface,
4469            'egress_filter': self.egress_filter,
4470            'healthy': self.healthy,
4471            'hostname': self.hostname,
4472            'id': self.id,
4473            'name': self.name,
4474            'password': self.password,
4475            'port': self.port,
4476            'port_override': self.port_override,
4477            'secret_store_id': self.secret_store_id,
4478            'tags': self.tags,
4479            'username': self.username,
4480        }
@classmethod
def from_dict(cls, d)
4482    @classmethod
4483    def from_dict(cls, d):
4484        return cls(
4485            auth_database=d.get('auth_database'),
4486            bind_interface=d.get('bind_interface'),
4487            egress_filter=d.get('egress_filter'),
4488            healthy=d.get('healthy'),
4489            hostname=d.get('hostname'),
4490            id=d.get('id'),
4491            name=d.get('name'),
4492            password=d.get('password'),
4493            port=d.get('port'),
4494            port_override=d.get('port_override'),
4495            secret_store_id=d.get('secret_store_id'),
4496            tags=d.get('tags'),
4497            username=d.get('username'),
4498        )
class DocumentDBReplicaSet:
4501class DocumentDBReplicaSet:
4502    __slots__ = [
4503        'auth_database',
4504        'bind_interface',
4505        'connect_to_replica',
4506        'egress_filter',
4507        'healthy',
4508        'hostname',
4509        'id',
4510        'name',
4511        'password',
4512        'port_override',
4513        'replica_set',
4514        'secret_store_id',
4515        'tags',
4516        'username',
4517    ]
4518
4519    def __init__(
4520        self,
4521        auth_database=None,
4522        bind_interface=None,
4523        connect_to_replica=None,
4524        egress_filter=None,
4525        healthy=None,
4526        hostname=None,
4527        id=None,
4528        name=None,
4529        password=None,
4530        port_override=None,
4531        replica_set=None,
4532        secret_store_id=None,
4533        tags=None,
4534        username=None,
4535    ):
4536        self.auth_database = auth_database if auth_database is not None else ''
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4542        self.egress_filter = egress_filter if egress_filter is not None else ''
4543        '''
4544         A filter applied to the routing logic to pin datasource to nodes.
4545        '''
4546        self.healthy = healthy if healthy is not None else False
4547        '''
4548         True if the datasource is reachable and the credentials are valid.
4549        '''
4550        self.hostname = hostname if hostname is not None else ''
4551        '''
4552         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4553        '''
4554        self.id = id if id is not None else ''
4555        '''
4556         Unique identifier of the Resource.
4557        '''
4558        self.name = name if name is not None else ''
4559        '''
4560         Unique human-readable name of the Resource.
4561        '''
4562        self.password = password if password is not None else ''
4563        self.port_override = port_override if port_override is not None else 0
4564        self.replica_set = replica_set if replica_set is not None else ''
4565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4566        '''
4567         ID of the secret store containing credentials for this resource, if any.
4568        '''
4569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4570        '''
4571         Tags is a map of key, value pairs.
4572        '''
4573        self.username = username if username is not None else ''
4574
4575    def __repr__(self):
4576        return '<sdm.DocumentDBReplicaSet ' + \
4577            'auth_database: ' + repr(self.auth_database) + ' ' +\
4578            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4579            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4580            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4581            'healthy: ' + repr(self.healthy) + ' ' +\
4582            'hostname: ' + repr(self.hostname) + ' ' +\
4583            'id: ' + repr(self.id) + ' ' +\
4584            'name: ' + repr(self.name) + ' ' +\
4585            'password: ' + repr(self.password) + ' ' +\
4586            'port_override: ' + repr(self.port_override) + ' ' +\
4587            'replica_set: ' + repr(self.replica_set) + ' ' +\
4588            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4589            'tags: ' + repr(self.tags) + ' ' +\
4590            'username: ' + repr(self.username) + ' ' +\
4591            '>'
4592
4593    def to_dict(self):
4594        return {
4595            'auth_database': self.auth_database,
4596            'bind_interface': self.bind_interface,
4597            'connect_to_replica': self.connect_to_replica,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port_override': self.port_override,
4605            'replica_set': self.replica_set,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'username': self.username,
4609        }
4610
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            auth_database=d.get('auth_database'),
4615            bind_interface=d.get('bind_interface'),
4616            connect_to_replica=d.get('connect_to_replica'),
4617            egress_filter=d.get('egress_filter'),
4618            healthy=d.get('healthy'),
4619            hostname=d.get('hostname'),
4620            id=d.get('id'),
4621            name=d.get('name'),
4622            password=d.get('password'),
4623            port_override=d.get('port_override'),
4624            replica_set=d.get('replica_set'),
4625            secret_store_id=d.get('secret_store_id'),
4626            tags=d.get('tags'),
4627            username=d.get('username'),
4628        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4519    def __init__(
4520        self,
4521        auth_database=None,
4522        bind_interface=None,
4523        connect_to_replica=None,
4524        egress_filter=None,
4525        healthy=None,
4526        hostname=None,
4527        id=None,
4528        name=None,
4529        password=None,
4530        port_override=None,
4531        replica_set=None,
4532        secret_store_id=None,
4533        tags=None,
4534        username=None,
4535    ):
4536        self.auth_database = auth_database if auth_database is not None else ''
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4542        self.egress_filter = egress_filter if egress_filter is not None else ''
4543        '''
4544         A filter applied to the routing logic to pin datasource to nodes.
4545        '''
4546        self.healthy = healthy if healthy is not None else False
4547        '''
4548         True if the datasource is reachable and the credentials are valid.
4549        '''
4550        self.hostname = hostname if hostname is not None else ''
4551        '''
4552         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4553        '''
4554        self.id = id if id is not None else ''
4555        '''
4556         Unique identifier of the Resource.
4557        '''
4558        self.name = name if name is not None else ''
4559        '''
4560         Unique human-readable name of the Resource.
4561        '''
4562        self.password = password if password is not None else ''
4563        self.port_override = port_override if port_override is not None else 0
4564        self.replica_set = replica_set if replica_set is not None else ''
4565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4566        '''
4567         ID of the secret store containing credentials for this resource, if any.
4568        '''
4569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4570        '''
4571         Tags is a map of key, value pairs.
4572        '''
4573        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4593    def to_dict(self):
4594        return {
4595            'auth_database': self.auth_database,
4596            'bind_interface': self.bind_interface,
4597            'connect_to_replica': self.connect_to_replica,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port_override': self.port_override,
4605            'replica_set': self.replica_set,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'username': self.username,
4609        }
@classmethod
def from_dict(cls, d)
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            auth_database=d.get('auth_database'),
4615            bind_interface=d.get('bind_interface'),
4616            connect_to_replica=d.get('connect_to_replica'),
4617            egress_filter=d.get('egress_filter'),
4618            healthy=d.get('healthy'),
4619            hostname=d.get('hostname'),
4620            id=d.get('id'),
4621            name=d.get('name'),
4622            password=d.get('password'),
4623            port_override=d.get('port_override'),
4624            replica_set=d.get('replica_set'),
4625            secret_store_id=d.get('secret_store_id'),
4626            tags=d.get('tags'),
4627            username=d.get('username'),
4628        )
class Druid:
4631class Druid:
4632    __slots__ = [
4633        'bind_interface',
4634        'egress_filter',
4635        'healthy',
4636        'hostname',
4637        'id',
4638        'name',
4639        'password',
4640        'port',
4641        'port_override',
4642        'secret_store_id',
4643        'tags',
4644        'username',
4645    ]
4646
4647    def __init__(
4648        self,
4649        bind_interface=None,
4650        egress_filter=None,
4651        healthy=None,
4652        hostname=None,
4653        id=None,
4654        name=None,
4655        password=None,
4656        port=None,
4657        port_override=None,
4658        secret_store_id=None,
4659        tags=None,
4660        username=None,
4661    ):
4662        self.bind_interface = bind_interface if bind_interface is not None else ''
4663        '''
4664         Bind interface
4665        '''
4666        self.egress_filter = egress_filter if egress_filter is not None else ''
4667        '''
4668         A filter applied to the routing logic to pin datasource to nodes.
4669        '''
4670        self.healthy = healthy if healthy is not None else False
4671        '''
4672         True if the datasource is reachable and the credentials are valid.
4673        '''
4674        self.hostname = hostname if hostname is not None else ''
4675        self.id = id if id is not None else ''
4676        '''
4677         Unique identifier of the Resource.
4678        '''
4679        self.name = name if name is not None else ''
4680        '''
4681         Unique human-readable name of the Resource.
4682        '''
4683        self.password = password if password is not None else ''
4684        self.port = port if port is not None else 0
4685        self.port_override = port_override if port_override is not None else 0
4686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4687        '''
4688         ID of the secret store containing credentials for this resource, if any.
4689        '''
4690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4691        '''
4692         Tags is a map of key, value pairs.
4693        '''
4694        self.username = username if username is not None else ''
4695
4696    def __repr__(self):
4697        return '<sdm.Druid ' + \
4698            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4699            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4700            'healthy: ' + repr(self.healthy) + ' ' +\
4701            'hostname: ' + repr(self.hostname) + ' ' +\
4702            'id: ' + repr(self.id) + ' ' +\
4703            'name: ' + repr(self.name) + ' ' +\
4704            'password: ' + repr(self.password) + ' ' +\
4705            'port: ' + repr(self.port) + ' ' +\
4706            'port_override: ' + repr(self.port_override) + ' ' +\
4707            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4708            'tags: ' + repr(self.tags) + ' ' +\
4709            'username: ' + repr(self.username) + ' ' +\
4710            '>'
4711
4712    def to_dict(self):
4713        return {
4714            'bind_interface': self.bind_interface,
4715            'egress_filter': self.egress_filter,
4716            'healthy': self.healthy,
4717            'hostname': self.hostname,
4718            'id': self.id,
4719            'name': self.name,
4720            'password': self.password,
4721            'port': self.port,
4722            'port_override': self.port_override,
4723            'secret_store_id': self.secret_store_id,
4724            'tags': self.tags,
4725            'username': self.username,
4726        }
4727
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            bind_interface=d.get('bind_interface'),
4732            egress_filter=d.get('egress_filter'),
4733            healthy=d.get('healthy'),
4734            hostname=d.get('hostname'),
4735            id=d.get('id'),
4736            name=d.get('name'),
4737            password=d.get('password'),
4738            port=d.get('port'),
4739            port_override=d.get('port_override'),
4740            secret_store_id=d.get('secret_store_id'),
4741            tags=d.get('tags'),
4742            username=d.get('username'),
4743        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4647    def __init__(
4648        self,
4649        bind_interface=None,
4650        egress_filter=None,
4651        healthy=None,
4652        hostname=None,
4653        id=None,
4654        name=None,
4655        password=None,
4656        port=None,
4657        port_override=None,
4658        secret_store_id=None,
4659        tags=None,
4660        username=None,
4661    ):
4662        self.bind_interface = bind_interface if bind_interface is not None else ''
4663        '''
4664         Bind interface
4665        '''
4666        self.egress_filter = egress_filter if egress_filter is not None else ''
4667        '''
4668         A filter applied to the routing logic to pin datasource to nodes.
4669        '''
4670        self.healthy = healthy if healthy is not None else False
4671        '''
4672         True if the datasource is reachable and the credentials are valid.
4673        '''
4674        self.hostname = hostname if hostname is not None else ''
4675        self.id = id if id is not None else ''
4676        '''
4677         Unique identifier of the Resource.
4678        '''
4679        self.name = name if name is not None else ''
4680        '''
4681         Unique human-readable name of the Resource.
4682        '''
4683        self.password = password if password is not None else ''
4684        self.port = port if port is not None else 0
4685        self.port_override = port_override if port_override is not None else 0
4686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4687        '''
4688         ID of the secret store containing credentials for this resource, if any.
4689        '''
4690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4691        '''
4692         Tags is a map of key, value pairs.
4693        '''
4694        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4712    def to_dict(self):
4713        return {
4714            'bind_interface': self.bind_interface,
4715            'egress_filter': self.egress_filter,
4716            'healthy': self.healthy,
4717            'hostname': self.hostname,
4718            'id': self.id,
4719            'name': self.name,
4720            'password': self.password,
4721            'port': self.port,
4722            'port_override': self.port_override,
4723            'secret_store_id': self.secret_store_id,
4724            'tags': self.tags,
4725            'username': self.username,
4726        }
@classmethod
def from_dict(cls, d)
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            bind_interface=d.get('bind_interface'),
4732            egress_filter=d.get('egress_filter'),
4733            healthy=d.get('healthy'),
4734            hostname=d.get('hostname'),
4735            id=d.get('id'),
4736            name=d.get('name'),
4737            password=d.get('password'),
4738            port=d.get('port'),
4739            port_override=d.get('port_override'),
4740            secret_store_id=d.get('secret_store_id'),
4741            tags=d.get('tags'),
4742            username=d.get('username'),
4743        )
class DynamoDB:
4746class DynamoDB:
4747    __slots__ = [
4748        'access_key',
4749        'bind_interface',
4750        'egress_filter',
4751        'endpoint',
4752        'healthy',
4753        'id',
4754        'name',
4755        'port_override',
4756        'region',
4757        'role_arn',
4758        'role_external_id',
4759        'secret_access_key',
4760        'secret_store_id',
4761        'tags',
4762    ]
4763
4764    def __init__(
4765        self,
4766        access_key=None,
4767        bind_interface=None,
4768        egress_filter=None,
4769        endpoint=None,
4770        healthy=None,
4771        id=None,
4772        name=None,
4773        port_override=None,
4774        region=None,
4775        role_arn=None,
4776        role_external_id=None,
4777        secret_access_key=None,
4778        secret_store_id=None,
4779        tags=None,
4780    ):
4781        self.access_key = access_key if access_key is not None else ''
4782        self.bind_interface = bind_interface if bind_interface is not None else ''
4783        '''
4784         Bind interface
4785        '''
4786        self.egress_filter = egress_filter if egress_filter is not None else ''
4787        '''
4788         A filter applied to the routing logic to pin datasource to nodes.
4789        '''
4790        self.endpoint = endpoint if endpoint is not None else ''
4791        self.healthy = healthy if healthy is not None else False
4792        '''
4793         True if the datasource is reachable and the credentials are valid.
4794        '''
4795        self.id = id if id is not None else ''
4796        '''
4797         Unique identifier of the Resource.
4798        '''
4799        self.name = name if name is not None else ''
4800        '''
4801         Unique human-readable name of the Resource.
4802        '''
4803        self.port_override = port_override if port_override is not None else 0
4804        self.region = region if region is not None else ''
4805        self.role_arn = role_arn if role_arn is not None else ''
4806        self.role_external_id = role_external_id if role_external_id is not None else ''
4807        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4809        '''
4810         ID of the secret store containing credentials for this resource, if any.
4811        '''
4812        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4813        '''
4814         Tags is a map of key, value pairs.
4815        '''
4816
4817    def __repr__(self):
4818        return '<sdm.DynamoDB ' + \
4819            'access_key: ' + repr(self.access_key) + ' ' +\
4820            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4821            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4822            'endpoint: ' + repr(self.endpoint) + ' ' +\
4823            'healthy: ' + repr(self.healthy) + ' ' +\
4824            'id: ' + repr(self.id) + ' ' +\
4825            'name: ' + repr(self.name) + ' ' +\
4826            'port_override: ' + repr(self.port_override) + ' ' +\
4827            'region: ' + repr(self.region) + ' ' +\
4828            'role_arn: ' + repr(self.role_arn) + ' ' +\
4829            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4830            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4831            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4832            'tags: ' + repr(self.tags) + ' ' +\
4833            '>'
4834
4835    def to_dict(self):
4836        return {
4837            'access_key': self.access_key,
4838            'bind_interface': self.bind_interface,
4839            'egress_filter': self.egress_filter,
4840            'endpoint': self.endpoint,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'name': self.name,
4844            'port_override': self.port_override,
4845            'region': self.region,
4846            'role_arn': self.role_arn,
4847            'role_external_id': self.role_external_id,
4848            'secret_access_key': self.secret_access_key,
4849            'secret_store_id': self.secret_store_id,
4850            'tags': self.tags,
4851        }
4852
4853    @classmethod
4854    def from_dict(cls, d):
4855        return cls(
4856            access_key=d.get('access_key'),
4857            bind_interface=d.get('bind_interface'),
4858            egress_filter=d.get('egress_filter'),
4859            endpoint=d.get('endpoint'),
4860            healthy=d.get('healthy'),
4861            id=d.get('id'),
4862            name=d.get('name'),
4863            port_override=d.get('port_override'),
4864            region=d.get('region'),
4865            role_arn=d.get('role_arn'),
4866            role_external_id=d.get('role_external_id'),
4867            secret_access_key=d.get('secret_access_key'),
4868            secret_store_id=d.get('secret_store_id'),
4869            tags=d.get('tags'),
4870        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4764    def __init__(
4765        self,
4766        access_key=None,
4767        bind_interface=None,
4768        egress_filter=None,
4769        endpoint=None,
4770        healthy=None,
4771        id=None,
4772        name=None,
4773        port_override=None,
4774        region=None,
4775        role_arn=None,
4776        role_external_id=None,
4777        secret_access_key=None,
4778        secret_store_id=None,
4779        tags=None,
4780    ):
4781        self.access_key = access_key if access_key is not None else ''
4782        self.bind_interface = bind_interface if bind_interface is not None else ''
4783        '''
4784         Bind interface
4785        '''
4786        self.egress_filter = egress_filter if egress_filter is not None else ''
4787        '''
4788         A filter applied to the routing logic to pin datasource to nodes.
4789        '''
4790        self.endpoint = endpoint if endpoint is not None else ''
4791        self.healthy = healthy if healthy is not None else False
4792        '''
4793         True if the datasource is reachable and the credentials are valid.
4794        '''
4795        self.id = id if id is not None else ''
4796        '''
4797         Unique identifier of the Resource.
4798        '''
4799        self.name = name if name is not None else ''
4800        '''
4801         Unique human-readable name of the Resource.
4802        '''
4803        self.port_override = port_override if port_override is not None else 0
4804        self.region = region if region is not None else ''
4805        self.role_arn = role_arn if role_arn is not None else ''
4806        self.role_external_id = role_external_id if role_external_id is not None else ''
4807        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4809        '''
4810         ID of the secret store containing credentials for this resource, if any.
4811        '''
4812        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4813        '''
4814         Tags is a map of key, value pairs.
4815        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4835    def to_dict(self):
4836        return {
4837            'access_key': self.access_key,
4838            'bind_interface': self.bind_interface,
4839            'egress_filter': self.egress_filter,
4840            'endpoint': self.endpoint,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'name': self.name,
4844            'port_override': self.port_override,
4845            'region': self.region,
4846            'role_arn': self.role_arn,
4847            'role_external_id': self.role_external_id,
4848            'secret_access_key': self.secret_access_key,
4849            'secret_store_id': self.secret_store_id,
4850            'tags': self.tags,
4851        }
@classmethod
def from_dict(cls, d)
4853    @classmethod
4854    def from_dict(cls, d):
4855        return cls(
4856            access_key=d.get('access_key'),
4857            bind_interface=d.get('bind_interface'),
4858            egress_filter=d.get('egress_filter'),
4859            endpoint=d.get('endpoint'),
4860            healthy=d.get('healthy'),
4861            id=d.get('id'),
4862            name=d.get('name'),
4863            port_override=d.get('port_override'),
4864            region=d.get('region'),
4865            role_arn=d.get('role_arn'),
4866            role_external_id=d.get('role_external_id'),
4867            secret_access_key=d.get('secret_access_key'),
4868            secret_store_id=d.get('secret_store_id'),
4869            tags=d.get('tags'),
4870        )
class Elastic:
4873class Elastic:
4874    __slots__ = [
4875        'bind_interface',
4876        'egress_filter',
4877        'healthy',
4878        'hostname',
4879        'id',
4880        'name',
4881        'password',
4882        'port',
4883        'port_override',
4884        'secret_store_id',
4885        'tags',
4886        'tls_required',
4887        'username',
4888    ]
4889
4890    def __init__(
4891        self,
4892        bind_interface=None,
4893        egress_filter=None,
4894        healthy=None,
4895        hostname=None,
4896        id=None,
4897        name=None,
4898        password=None,
4899        port=None,
4900        port_override=None,
4901        secret_store_id=None,
4902        tags=None,
4903        tls_required=None,
4904        username=None,
4905    ):
4906        self.bind_interface = bind_interface if bind_interface is not None else ''
4907        '''
4908         Bind interface
4909        '''
4910        self.egress_filter = egress_filter if egress_filter is not None else ''
4911        '''
4912         A filter applied to the routing logic to pin datasource to nodes.
4913        '''
4914        self.healthy = healthy if healthy is not None else False
4915        '''
4916         True if the datasource is reachable and the credentials are valid.
4917        '''
4918        self.hostname = hostname if hostname is not None else ''
4919        self.id = id if id is not None else ''
4920        '''
4921         Unique identifier of the Resource.
4922        '''
4923        self.name = name if name is not None else ''
4924        '''
4925         Unique human-readable name of the Resource.
4926        '''
4927        self.password = password if password is not None else ''
4928        self.port = port if port is not None else 0
4929        self.port_override = port_override if port_override is not None else 0
4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4931        '''
4932         ID of the secret store containing credentials for this resource, if any.
4933        '''
4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4935        '''
4936         Tags is a map of key, value pairs.
4937        '''
4938        self.tls_required = tls_required if tls_required is not None else False
4939        self.username = username if username is not None else ''
4940
4941    def __repr__(self):
4942        return '<sdm.Elastic ' + \
4943            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4944            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4945            'healthy: ' + repr(self.healthy) + ' ' +\
4946            'hostname: ' + repr(self.hostname) + ' ' +\
4947            'id: ' + repr(self.id) + ' ' +\
4948            'name: ' + repr(self.name) + ' ' +\
4949            'password: ' + repr(self.password) + ' ' +\
4950            'port: ' + repr(self.port) + ' ' +\
4951            'port_override: ' + repr(self.port_override) + ' ' +\
4952            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4953            'tags: ' + repr(self.tags) + ' ' +\
4954            'tls_required: ' + repr(self.tls_required) + ' ' +\
4955            'username: ' + repr(self.username) + ' ' +\
4956            '>'
4957
4958    def to_dict(self):
4959        return {
4960            'bind_interface': self.bind_interface,
4961            'egress_filter': self.egress_filter,
4962            'healthy': self.healthy,
4963            'hostname': self.hostname,
4964            'id': self.id,
4965            'name': self.name,
4966            'password': self.password,
4967            'port': self.port,
4968            'port_override': self.port_override,
4969            'secret_store_id': self.secret_store_id,
4970            'tags': self.tags,
4971            'tls_required': self.tls_required,
4972            'username': self.username,
4973        }
4974
4975    @classmethod
4976    def from_dict(cls, d):
4977        return cls(
4978            bind_interface=d.get('bind_interface'),
4979            egress_filter=d.get('egress_filter'),
4980            healthy=d.get('healthy'),
4981            hostname=d.get('hostname'),
4982            id=d.get('id'),
4983            name=d.get('name'),
4984            password=d.get('password'),
4985            port=d.get('port'),
4986            port_override=d.get('port_override'),
4987            secret_store_id=d.get('secret_store_id'),
4988            tags=d.get('tags'),
4989            tls_required=d.get('tls_required'),
4990            username=d.get('username'),
4991        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4890    def __init__(
4891        self,
4892        bind_interface=None,
4893        egress_filter=None,
4894        healthy=None,
4895        hostname=None,
4896        id=None,
4897        name=None,
4898        password=None,
4899        port=None,
4900        port_override=None,
4901        secret_store_id=None,
4902        tags=None,
4903        tls_required=None,
4904        username=None,
4905    ):
4906        self.bind_interface = bind_interface if bind_interface is not None else ''
4907        '''
4908         Bind interface
4909        '''
4910        self.egress_filter = egress_filter if egress_filter is not None else ''
4911        '''
4912         A filter applied to the routing logic to pin datasource to nodes.
4913        '''
4914        self.healthy = healthy if healthy is not None else False
4915        '''
4916         True if the datasource is reachable and the credentials are valid.
4917        '''
4918        self.hostname = hostname if hostname is not None else ''
4919        self.id = id if id is not None else ''
4920        '''
4921         Unique identifier of the Resource.
4922        '''
4923        self.name = name if name is not None else ''
4924        '''
4925         Unique human-readable name of the Resource.
4926        '''
4927        self.password = password if password is not None else ''
4928        self.port = port if port is not None else 0
4929        self.port_override = port_override if port_override is not None else 0
4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4931        '''
4932         ID of the secret store containing credentials for this resource, if any.
4933        '''
4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4935        '''
4936         Tags is a map of key, value pairs.
4937        '''
4938        self.tls_required = tls_required if tls_required is not None else False
4939        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4958    def to_dict(self):
4959        return {
4960            'bind_interface': self.bind_interface,
4961            'egress_filter': self.egress_filter,
4962            'healthy': self.healthy,
4963            'hostname': self.hostname,
4964            'id': self.id,
4965            'name': self.name,
4966            'password': self.password,
4967            'port': self.port,
4968            'port_override': self.port_override,
4969            'secret_store_id': self.secret_store_id,
4970            'tags': self.tags,
4971            'tls_required': self.tls_required,
4972            'username': self.username,
4973        }
@classmethod
def from_dict(cls, d)
4975    @classmethod
4976    def from_dict(cls, d):
4977        return cls(
4978            bind_interface=d.get('bind_interface'),
4979            egress_filter=d.get('egress_filter'),
4980            healthy=d.get('healthy'),
4981            hostname=d.get('hostname'),
4982            id=d.get('id'),
4983            name=d.get('name'),
4984            password=d.get('password'),
4985            port=d.get('port'),
4986            port_override=d.get('port_override'),
4987            secret_store_id=d.get('secret_store_id'),
4988            tags=d.get('tags'),
4989            tls_required=d.get('tls_required'),
4990            username=d.get('username'),
4991        )
class ElasticacheRedis:
4994class ElasticacheRedis:
4995    __slots__ = [
4996        'bind_interface',
4997        'egress_filter',
4998        'healthy',
4999        'hostname',
5000        'id',
5001        'name',
5002        'password',
5003        'port',
5004        'port_override',
5005        'secret_store_id',
5006        'tags',
5007        'tls_required',
5008    ]
5009
5010    def __init__(
5011        self,
5012        bind_interface=None,
5013        egress_filter=None,
5014        healthy=None,
5015        hostname=None,
5016        id=None,
5017        name=None,
5018        password=None,
5019        port=None,
5020        port_override=None,
5021        secret_store_id=None,
5022        tags=None,
5023        tls_required=None,
5024    ):
5025        self.bind_interface = bind_interface if bind_interface is not None else ''
5026        '''
5027         Bind interface
5028        '''
5029        self.egress_filter = egress_filter if egress_filter is not None else ''
5030        '''
5031         A filter applied to the routing logic to pin datasource to nodes.
5032        '''
5033        self.healthy = healthy if healthy is not None else False
5034        '''
5035         True if the datasource is reachable and the credentials are valid.
5036        '''
5037        self.hostname = hostname if hostname is not None else ''
5038        self.id = id if id is not None else ''
5039        '''
5040         Unique identifier of the Resource.
5041        '''
5042        self.name = name if name is not None else ''
5043        '''
5044         Unique human-readable name of the Resource.
5045        '''
5046        self.password = password if password is not None else ''
5047        self.port = port if port is not None else 0
5048        self.port_override = port_override if port_override is not None else 0
5049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5050        '''
5051         ID of the secret store containing credentials for this resource, if any.
5052        '''
5053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5054        '''
5055         Tags is a map of key, value pairs.
5056        '''
5057        self.tls_required = tls_required if tls_required is not None else False
5058
5059    def __repr__(self):
5060        return '<sdm.ElasticacheRedis ' + \
5061            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5062            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5063            'healthy: ' + repr(self.healthy) + ' ' +\
5064            'hostname: ' + repr(self.hostname) + ' ' +\
5065            'id: ' + repr(self.id) + ' ' +\
5066            'name: ' + repr(self.name) + ' ' +\
5067            'password: ' + repr(self.password) + ' ' +\
5068            'port: ' + repr(self.port) + ' ' +\
5069            'port_override: ' + repr(self.port_override) + ' ' +\
5070            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5071            'tags: ' + repr(self.tags) + ' ' +\
5072            'tls_required: ' + repr(self.tls_required) + ' ' +\
5073            '>'
5074
5075    def to_dict(self):
5076        return {
5077            'bind_interface': self.bind_interface,
5078            'egress_filter': self.egress_filter,
5079            'healthy': self.healthy,
5080            'hostname': self.hostname,
5081            'id': self.id,
5082            'name': self.name,
5083            'password': self.password,
5084            'port': self.port,
5085            'port_override': self.port_override,
5086            'secret_store_id': self.secret_store_id,
5087            'tags': self.tags,
5088            'tls_required': self.tls_required,
5089        }
5090
5091    @classmethod
5092    def from_dict(cls, d):
5093        return cls(
5094            bind_interface=d.get('bind_interface'),
5095            egress_filter=d.get('egress_filter'),
5096            healthy=d.get('healthy'),
5097            hostname=d.get('hostname'),
5098            id=d.get('id'),
5099            name=d.get('name'),
5100            password=d.get('password'),
5101            port=d.get('port'),
5102            port_override=d.get('port_override'),
5103            secret_store_id=d.get('secret_store_id'),
5104            tags=d.get('tags'),
5105            tls_required=d.get('tls_required'),
5106        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
5010    def __init__(
5011        self,
5012        bind_interface=None,
5013        egress_filter=None,
5014        healthy=None,
5015        hostname=None,
5016        id=None,
5017        name=None,
5018        password=None,
5019        port=None,
5020        port_override=None,
5021        secret_store_id=None,
5022        tags=None,
5023        tls_required=None,
5024    ):
5025        self.bind_interface = bind_interface if bind_interface is not None else ''
5026        '''
5027         Bind interface
5028        '''
5029        self.egress_filter = egress_filter if egress_filter is not None else ''
5030        '''
5031         A filter applied to the routing logic to pin datasource to nodes.
5032        '''
5033        self.healthy = healthy if healthy is not None else False
5034        '''
5035         True if the datasource is reachable and the credentials are valid.
5036        '''
5037        self.hostname = hostname if hostname is not None else ''
5038        self.id = id if id is not None else ''
5039        '''
5040         Unique identifier of the Resource.
5041        '''
5042        self.name = name if name is not None else ''
5043        '''
5044         Unique human-readable name of the Resource.
5045        '''
5046        self.password = password if password is not None else ''
5047        self.port = port if port is not None else 0
5048        self.port_override = port_override if port_override is not None else 0
5049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5050        '''
5051         ID of the secret store containing credentials for this resource, if any.
5052        '''
5053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5054        '''
5055         Tags is a map of key, value pairs.
5056        '''
5057        self.tls_required = tls_required if tls_required is not None else False
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
5075    def to_dict(self):
5076        return {
5077            'bind_interface': self.bind_interface,
5078            'egress_filter': self.egress_filter,
5079            'healthy': self.healthy,
5080            'hostname': self.hostname,
5081            'id': self.id,
5082            'name': self.name,
5083            'password': self.password,
5084            'port': self.port,
5085            'port_override': self.port_override,
5086            'secret_store_id': self.secret_store_id,
5087            'tags': self.tags,
5088            'tls_required': self.tls_required,
5089        }
@classmethod
def from_dict(cls, d)
5091    @classmethod
5092    def from_dict(cls, d):
5093        return cls(
5094            bind_interface=d.get('bind_interface'),
5095            egress_filter=d.get('egress_filter'),
5096            healthy=d.get('healthy'),
5097            hostname=d.get('hostname'),
5098            id=d.get('id'),
5099            name=d.get('name'),
5100            password=d.get('password'),
5101            port=d.get('port'),
5102            port_override=d.get('port_override'),
5103            secret_store_id=d.get('secret_store_id'),
5104            tags=d.get('tags'),
5105            tls_required=d.get('tls_required'),
5106        )
class GCP:
5109class GCP:
5110    __slots__ = [
5111        'bind_interface',
5112        'egress_filter',
5113        'healthy',
5114        'id',
5115        'keyfile',
5116        'name',
5117        'scopes',
5118        'secret_store_id',
5119        'tags',
5120    ]
5121
5122    def __init__(
5123        self,
5124        bind_interface=None,
5125        egress_filter=None,
5126        healthy=None,
5127        id=None,
5128        keyfile=None,
5129        name=None,
5130        scopes=None,
5131        secret_store_id=None,
5132        tags=None,
5133    ):
5134        self.bind_interface = bind_interface if bind_interface is not None else ''
5135        '''
5136         Bind interface
5137        '''
5138        self.egress_filter = egress_filter if egress_filter is not None else ''
5139        '''
5140         A filter applied to the routing logic to pin datasource to nodes.
5141        '''
5142        self.healthy = healthy if healthy is not None else False
5143        '''
5144         True if the datasource is reachable and the credentials are valid.
5145        '''
5146        self.id = id if id is not None else ''
5147        '''
5148         Unique identifier of the Resource.
5149        '''
5150        self.keyfile = keyfile if keyfile is not None else ''
5151        self.name = name if name is not None else ''
5152        '''
5153         Unique human-readable name of the Resource.
5154        '''
5155        self.scopes = scopes if scopes is not None else ''
5156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5157        '''
5158         ID of the secret store containing credentials for this resource, if any.
5159        '''
5160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5161        '''
5162         Tags is a map of key, value pairs.
5163        '''
5164
5165    def __repr__(self):
5166        return '<sdm.GCP ' + \
5167            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5168            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5169            'healthy: ' + repr(self.healthy) + ' ' +\
5170            'id: ' + repr(self.id) + ' ' +\
5171            'keyfile: ' + repr(self.keyfile) + ' ' +\
5172            'name: ' + repr(self.name) + ' ' +\
5173            'scopes: ' + repr(self.scopes) + ' ' +\
5174            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5175            'tags: ' + repr(self.tags) + ' ' +\
5176            '>'
5177
5178    def to_dict(self):
5179        return {
5180            'bind_interface': self.bind_interface,
5181            'egress_filter': self.egress_filter,
5182            'healthy': self.healthy,
5183            'id': self.id,
5184            'keyfile': self.keyfile,
5185            'name': self.name,
5186            'scopes': self.scopes,
5187            'secret_store_id': self.secret_store_id,
5188            'tags': self.tags,
5189        }
5190
5191    @classmethod
5192    def from_dict(cls, d):
5193        return cls(
5194            bind_interface=d.get('bind_interface'),
5195            egress_filter=d.get('egress_filter'),
5196            healthy=d.get('healthy'),
5197            id=d.get('id'),
5198            keyfile=d.get('keyfile'),
5199            name=d.get('name'),
5200            scopes=d.get('scopes'),
5201            secret_store_id=d.get('secret_store_id'),
5202            tags=d.get('tags'),
5203        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5122    def __init__(
5123        self,
5124        bind_interface=None,
5125        egress_filter=None,
5126        healthy=None,
5127        id=None,
5128        keyfile=None,
5129        name=None,
5130        scopes=None,
5131        secret_store_id=None,
5132        tags=None,
5133    ):
5134        self.bind_interface = bind_interface if bind_interface is not None else ''
5135        '''
5136         Bind interface
5137        '''
5138        self.egress_filter = egress_filter if egress_filter is not None else ''
5139        '''
5140         A filter applied to the routing logic to pin datasource to nodes.
5141        '''
5142        self.healthy = healthy if healthy is not None else False
5143        '''
5144         True if the datasource is reachable and the credentials are valid.
5145        '''
5146        self.id = id if id is not None else ''
5147        '''
5148         Unique identifier of the Resource.
5149        '''
5150        self.keyfile = keyfile if keyfile is not None else ''
5151        self.name = name if name is not None else ''
5152        '''
5153         Unique human-readable name of the Resource.
5154        '''
5155        self.scopes = scopes if scopes is not None else ''
5156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5157        '''
5158         ID of the secret store containing credentials for this resource, if any.
5159        '''
5160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5161        '''
5162         Tags is a map of key, value pairs.
5163        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5178    def to_dict(self):
5179        return {
5180            'bind_interface': self.bind_interface,
5181            'egress_filter': self.egress_filter,
5182            'healthy': self.healthy,
5183            'id': self.id,
5184            'keyfile': self.keyfile,
5185            'name': self.name,
5186            'scopes': self.scopes,
5187            'secret_store_id': self.secret_store_id,
5188            'tags': self.tags,
5189        }
@classmethod
def from_dict(cls, d)
5191    @classmethod
5192    def from_dict(cls, d):
5193        return cls(
5194            bind_interface=d.get('bind_interface'),
5195            egress_filter=d.get('egress_filter'),
5196            healthy=d.get('healthy'),
5197            id=d.get('id'),
5198            keyfile=d.get('keyfile'),
5199            name=d.get('name'),
5200            scopes=d.get('scopes'),
5201            secret_store_id=d.get('secret_store_id'),
5202            tags=d.get('tags'),
5203        )
class GCPStore:
5206class GCPStore:
5207    __slots__ = [
5208        'id',
5209        'name',
5210        'projectid',
5211        'tags',
5212    ]
5213
5214    def __init__(
5215        self,
5216        id=None,
5217        name=None,
5218        projectid=None,
5219        tags=None,
5220    ):
5221        self.id = id if id is not None else ''
5222        '''
5223         Unique identifier of the SecretStore.
5224        '''
5225        self.name = name if name is not None else ''
5226        '''
5227         Unique human-readable name of the SecretStore.
5228        '''
5229        self.projectid = projectid if projectid is not None else ''
5230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5231        '''
5232         Tags is a map of key, value pairs.
5233        '''
5234
5235    def __repr__(self):
5236        return '<sdm.GCPStore ' + \
5237            'id: ' + repr(self.id) + ' ' +\
5238            'name: ' + repr(self.name) + ' ' +\
5239            'projectid: ' + repr(self.projectid) + ' ' +\
5240            'tags: ' + repr(self.tags) + ' ' +\
5241            '>'
5242
5243    def to_dict(self):
5244        return {
5245            'id': self.id,
5246            'name': self.name,
5247            'projectid': self.projectid,
5248            'tags': self.tags,
5249        }
5250
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            id=d.get('id'),
5255            name=d.get('name'),
5256            projectid=d.get('projectid'),
5257            tags=d.get('tags'),
5258        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5214    def __init__(
5215        self,
5216        id=None,
5217        name=None,
5218        projectid=None,
5219        tags=None,
5220    ):
5221        self.id = id if id is not None else ''
5222        '''
5223         Unique identifier of the SecretStore.
5224        '''
5225        self.name = name if name is not None else ''
5226        '''
5227         Unique human-readable name of the SecretStore.
5228        '''
5229        self.projectid = projectid if projectid is not None else ''
5230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5231        '''
5232         Tags is a map of key, value pairs.
5233        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5243    def to_dict(self):
5244        return {
5245            'id': self.id,
5246            'name': self.name,
5247            'projectid': self.projectid,
5248            'tags': self.tags,
5249        }
@classmethod
def from_dict(cls, d)
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            id=d.get('id'),
5255            name=d.get('name'),
5256            projectid=d.get('projectid'),
5257            tags=d.get('tags'),
5258        )
class Gateway:
5261class Gateway:
5262    '''
5263         Gateway represents a StrongDM CLI installation running in gateway mode.
5264    '''
5265    __slots__ = [
5266        'bind_address',
5267        'device',
5268        'gateway_filter',
5269        'id',
5270        'listen_address',
5271        'location',
5272        'name',
5273        'state',
5274        'tags',
5275        'version',
5276    ]
5277
5278    def __init__(
5279        self,
5280        bind_address=None,
5281        device=None,
5282        gateway_filter=None,
5283        id=None,
5284        listen_address=None,
5285        location=None,
5286        name=None,
5287        state=None,
5288        tags=None,
5289        version=None,
5290    ):
5291        self.bind_address = bind_address if bind_address is not None else ''
5292        '''
5293         The hostname/port tuple which the gateway daemon will bind to.
5294         If not provided on create, set to "0.0.0.0:listen_address_port".
5295        '''
5296        self.device = device if device is not None else ''
5297        '''
5298         Device is a read only device name uploaded by the gateway process when 
5299         it comes online.
5300        '''
5301        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5302        '''
5303         GatewayFilter can be used to restrict the peering between relays and
5304         gateways.
5305        '''
5306        self.id = id if id is not None else ''
5307        '''
5308         Unique identifier of the Gateway.
5309        '''
5310        self.listen_address = listen_address if listen_address is not None else ''
5311        '''
5312         The public hostname/port tuple at which the gateway will be accessible to clients.
5313        '''
5314        self.location = location if location is not None else ''
5315        '''
5316         Location is a read only network location uploaded by the gateway process
5317         when it comes online.
5318        '''
5319        self.name = name if name is not None else ''
5320        '''
5321         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5322        '''
5323        self.state = state if state is not None else ''
5324        '''
5325         The current state of the gateway. One of: "new", "verifying_restart",
5326         "restarting", "started", "stopped", "dead", "unknown"
5327        '''
5328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5329        '''
5330         Tags is a map of key, value pairs.
5331        '''
5332        self.version = version if version is not None else ''
5333        '''
5334         Version is a read only sdm binary version uploaded by the gateway process
5335         when it comes online.
5336        '''
5337
5338    def __repr__(self):
5339        return '<sdm.Gateway ' + \
5340            'bind_address: ' + repr(self.bind_address) + ' ' +\
5341            'device: ' + repr(self.device) + ' ' +\
5342            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5343            'id: ' + repr(self.id) + ' ' +\
5344            'listen_address: ' + repr(self.listen_address) + ' ' +\
5345            'location: ' + repr(self.location) + ' ' +\
5346            'name: ' + repr(self.name) + ' ' +\
5347            'state: ' + repr(self.state) + ' ' +\
5348            'tags: ' + repr(self.tags) + ' ' +\
5349            'version: ' + repr(self.version) + ' ' +\
5350            '>'
5351
5352    def to_dict(self):
5353        return {
5354            'bind_address': self.bind_address,
5355            'device': self.device,
5356            'gateway_filter': self.gateway_filter,
5357            'id': self.id,
5358            'listen_address': self.listen_address,
5359            'location': self.location,
5360            'name': self.name,
5361            'state': self.state,
5362            'tags': self.tags,
5363            'version': self.version,
5364        }
5365
5366    @classmethod
5367    def from_dict(cls, d):
5368        return cls(
5369            bind_address=d.get('bind_address'),
5370            device=d.get('device'),
5371            gateway_filter=d.get('gateway_filter'),
5372            id=d.get('id'),
5373            listen_address=d.get('listen_address'),
5374            location=d.get('location'),
5375            name=d.get('name'),
5376            state=d.get('state'),
5377            tags=d.get('tags'),
5378            version=d.get('version'),
5379        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, device=None, gateway_filter=None, id=None, listen_address=None, location=None, name=None, state=None, tags=None, version=None)
5278    def __init__(
5279        self,
5280        bind_address=None,
5281        device=None,
5282        gateway_filter=None,
5283        id=None,
5284        listen_address=None,
5285        location=None,
5286        name=None,
5287        state=None,
5288        tags=None,
5289        version=None,
5290    ):
5291        self.bind_address = bind_address if bind_address is not None else ''
5292        '''
5293         The hostname/port tuple which the gateway daemon will bind to.
5294         If not provided on create, set to "0.0.0.0:listen_address_port".
5295        '''
5296        self.device = device if device is not None else ''
5297        '''
5298         Device is a read only device name uploaded by the gateway process when 
5299         it comes online.
5300        '''
5301        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5302        '''
5303         GatewayFilter can be used to restrict the peering between relays and
5304         gateways.
5305        '''
5306        self.id = id if id is not None else ''
5307        '''
5308         Unique identifier of the Gateway.
5309        '''
5310        self.listen_address = listen_address if listen_address is not None else ''
5311        '''
5312         The public hostname/port tuple at which the gateway will be accessible to clients.
5313        '''
5314        self.location = location if location is not None else ''
5315        '''
5316         Location is a read only network location uploaded by the gateway process
5317         when it comes online.
5318        '''
5319        self.name = name if name is not None else ''
5320        '''
5321         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5322        '''
5323        self.state = state if state is not None else ''
5324        '''
5325         The current state of the gateway. One of: "new", "verifying_restart",
5326         "restarting", "started", "stopped", "dead", "unknown"
5327        '''
5328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5329        '''
5330         Tags is a map of key, value pairs.
5331        '''
5332        self.version = version if version is not None else ''
5333        '''
5334         Version is a read only sdm binary version uploaded by the gateway process
5335         when it comes online.
5336        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
5352    def to_dict(self):
5353        return {
5354            'bind_address': self.bind_address,
5355            'device': self.device,
5356            'gateway_filter': self.gateway_filter,
5357            'id': self.id,
5358            'listen_address': self.listen_address,
5359            'location': self.location,
5360            'name': self.name,
5361            'state': self.state,
5362            'tags': self.tags,
5363            'version': self.version,
5364        }
@classmethod
def from_dict(cls, d)
5366    @classmethod
5367    def from_dict(cls, d):
5368        return cls(
5369            bind_address=d.get('bind_address'),
5370            device=d.get('device'),
5371            gateway_filter=d.get('gateway_filter'),
5372            id=d.get('id'),
5373            listen_address=d.get('listen_address'),
5374            location=d.get('location'),
5375            name=d.get('name'),
5376            state=d.get('state'),
5377            tags=d.get('tags'),
5378            version=d.get('version'),
5379        )
class GetResponseMetadata:
5382class GetResponseMetadata:
5383    '''
5384         GetResponseMetadata is reserved for future use.
5385    '''
5386    __slots__ = []
5387
5388    def __init__(self, ):
5389        pass
5390
5391    def __repr__(self):
5392        return '<sdm.GetResponseMetadata ' + \
5393            '>'
5394
5395    def to_dict(self):
5396        return {}
5397
5398    @classmethod
5399    def from_dict(cls, d):
5400        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5388    def __init__(self, ):
5389        pass
def to_dict(self)
5395    def to_dict(self):
5396        return {}
@classmethod
def from_dict(cls, d)
5398    @classmethod
5399    def from_dict(cls, d):
5400        return cls()
class GoogleGKE:
5403class GoogleGKE:
5404    __slots__ = [
5405        'bind_interface',
5406        'certificate_authority',
5407        'egress_filter',
5408        'endpoint',
5409        'healthcheck_namespace',
5410        'healthy',
5411        'id',
5412        'name',
5413        'remote_identity_group_id',
5414        'remote_identity_healthcheck_username',
5415        'secret_store_id',
5416        'service_account_key',
5417        'tags',
5418    ]
5419
5420    def __init__(
5421        self,
5422        bind_interface=None,
5423        certificate_authority=None,
5424        egress_filter=None,
5425        endpoint=None,
5426        healthcheck_namespace=None,
5427        healthy=None,
5428        id=None,
5429        name=None,
5430        remote_identity_group_id=None,
5431        remote_identity_healthcheck_username=None,
5432        secret_store_id=None,
5433        service_account_key=None,
5434        tags=None,
5435    ):
5436        self.bind_interface = bind_interface if bind_interface is not None else ''
5437        '''
5438         Bind interface
5439        '''
5440        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5441        self.egress_filter = egress_filter if egress_filter is not None else ''
5442        '''
5443         A filter applied to the routing logic to pin datasource to nodes.
5444        '''
5445        self.endpoint = endpoint if endpoint is not None else ''
5446        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5447        '''
5448         The path used to check the health of your connection.  Defaults to `default`.
5449        '''
5450        self.healthy = healthy if healthy is not None else False
5451        '''
5452         True if the datasource is reachable and the credentials are valid.
5453        '''
5454        self.id = id if id is not None else ''
5455        '''
5456         Unique identifier of the Resource.
5457        '''
5458        self.name = name if name is not None else ''
5459        '''
5460         Unique human-readable name of the Resource.
5461        '''
5462        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5463        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5464        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5465        '''
5466         ID of the secret store containing credentials for this resource, if any.
5467        '''
5468        self.service_account_key = service_account_key if service_account_key is not None else ''
5469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5470        '''
5471         Tags is a map of key, value pairs.
5472        '''
5473
5474    def __repr__(self):
5475        return '<sdm.GoogleGKE ' + \
5476            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5477            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5478            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5479            'endpoint: ' + repr(self.endpoint) + ' ' +\
5480            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5481            'healthy: ' + repr(self.healthy) + ' ' +\
5482            'id: ' + repr(self.id) + ' ' +\
5483            'name: ' + repr(self.name) + ' ' +\
5484            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5485            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5486            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5487            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5488            'tags: ' + repr(self.tags) + ' ' +\
5489            '>'
5490
5491    def to_dict(self):
5492        return {
5493            'bind_interface': self.bind_interface,
5494            'certificate_authority': self.certificate_authority,
5495            'egress_filter': self.egress_filter,
5496            'endpoint': self.endpoint,
5497            'healthcheck_namespace': self.healthcheck_namespace,
5498            'healthy': self.healthy,
5499            'id': self.id,
5500            'name': self.name,
5501            'remote_identity_group_id': self.remote_identity_group_id,
5502            'remote_identity_healthcheck_username':
5503            self.remote_identity_healthcheck_username,
5504            'secret_store_id': self.secret_store_id,
5505            'service_account_key': self.service_account_key,
5506            'tags': self.tags,
5507        }
5508
5509    @classmethod
5510    def from_dict(cls, d):
5511        return cls(
5512            bind_interface=d.get('bind_interface'),
5513            certificate_authority=d.get('certificate_authority'),
5514            egress_filter=d.get('egress_filter'),
5515            endpoint=d.get('endpoint'),
5516            healthcheck_namespace=d.get('healthcheck_namespace'),
5517            healthy=d.get('healthy'),
5518            id=d.get('id'),
5519            name=d.get('name'),
5520            remote_identity_group_id=d.get('remote_identity_group_id'),
5521            remote_identity_healthcheck_username=d.get(
5522                'remote_identity_healthcheck_username'),
5523            secret_store_id=d.get('secret_store_id'),
5524            service_account_key=d.get('service_account_key'),
5525            tags=d.get('tags'),
5526        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5420    def __init__(
5421        self,
5422        bind_interface=None,
5423        certificate_authority=None,
5424        egress_filter=None,
5425        endpoint=None,
5426        healthcheck_namespace=None,
5427        healthy=None,
5428        id=None,
5429        name=None,
5430        remote_identity_group_id=None,
5431        remote_identity_healthcheck_username=None,
5432        secret_store_id=None,
5433        service_account_key=None,
5434        tags=None,
5435    ):
5436        self.bind_interface = bind_interface if bind_interface is not None else ''
5437        '''
5438         Bind interface
5439        '''
5440        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5441        self.egress_filter = egress_filter if egress_filter is not None else ''
5442        '''
5443         A filter applied to the routing logic to pin datasource to nodes.
5444        '''
5445        self.endpoint = endpoint if endpoint is not None else ''
5446        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5447        '''
5448         The path used to check the health of your connection.  Defaults to `default`.
5449        '''
5450        self.healthy = healthy if healthy is not None else False
5451        '''
5452         True if the datasource is reachable and the credentials are valid.
5453        '''
5454        self.id = id if id is not None else ''
5455        '''
5456         Unique identifier of the Resource.
5457        '''
5458        self.name = name if name is not None else ''
5459        '''
5460         Unique human-readable name of the Resource.
5461        '''
5462        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5463        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5464        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5465        '''
5466         ID of the secret store containing credentials for this resource, if any.
5467        '''
5468        self.service_account_key = service_account_key if service_account_key is not None else ''
5469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5470        '''
5471         Tags is a map of key, value pairs.
5472        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5491    def to_dict(self):
5492        return {
5493            'bind_interface': self.bind_interface,
5494            'certificate_authority': self.certificate_authority,
5495            'egress_filter': self.egress_filter,
5496            'endpoint': self.endpoint,
5497            'healthcheck_namespace': self.healthcheck_namespace,
5498            'healthy': self.healthy,
5499            'id': self.id,
5500            'name': self.name,
5501            'remote_identity_group_id': self.remote_identity_group_id,
5502            'remote_identity_healthcheck_username':
5503            self.remote_identity_healthcheck_username,
5504            'secret_store_id': self.secret_store_id,
5505            'service_account_key': self.service_account_key,
5506            'tags': self.tags,
5507        }
@classmethod
def from_dict(cls, d)
5509    @classmethod
5510    def from_dict(cls, d):
5511        return cls(
5512            bind_interface=d.get('bind_interface'),
5513            certificate_authority=d.get('certificate_authority'),
5514            egress_filter=d.get('egress_filter'),
5515            endpoint=d.get('endpoint'),
5516            healthcheck_namespace=d.get('healthcheck_namespace'),
5517            healthy=d.get('healthy'),
5518            id=d.get('id'),
5519            name=d.get('name'),
5520            remote_identity_group_id=d.get('remote_identity_group_id'),
5521            remote_identity_healthcheck_username=d.get(
5522                'remote_identity_healthcheck_username'),
5523            secret_store_id=d.get('secret_store_id'),
5524            service_account_key=d.get('service_account_key'),
5525            tags=d.get('tags'),
5526        )
class GoogleGKEUserImpersonation:
5529class GoogleGKEUserImpersonation:
5530    __slots__ = [
5531        'bind_interface',
5532        'certificate_authority',
5533        'egress_filter',
5534        'endpoint',
5535        'healthcheck_namespace',
5536        'healthy',
5537        'id',
5538        'name',
5539        'secret_store_id',
5540        'service_account_key',
5541        'tags',
5542    ]
5543
5544    def __init__(
5545        self,
5546        bind_interface=None,
5547        certificate_authority=None,
5548        egress_filter=None,
5549        endpoint=None,
5550        healthcheck_namespace=None,
5551        healthy=None,
5552        id=None,
5553        name=None,
5554        secret_store_id=None,
5555        service_account_key=None,
5556        tags=None,
5557    ):
5558        self.bind_interface = bind_interface if bind_interface is not None else ''
5559        '''
5560         Bind interface
5561        '''
5562        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5563        self.egress_filter = egress_filter if egress_filter is not None else ''
5564        '''
5565         A filter applied to the routing logic to pin datasource to nodes.
5566        '''
5567        self.endpoint = endpoint if endpoint is not None else ''
5568        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5569        '''
5570         The path used to check the health of your connection.  Defaults to `default`.
5571        '''
5572        self.healthy = healthy if healthy is not None else False
5573        '''
5574         True if the datasource is reachable and the credentials are valid.
5575        '''
5576        self.id = id if id is not None else ''
5577        '''
5578         Unique identifier of the Resource.
5579        '''
5580        self.name = name if name is not None else ''
5581        '''
5582         Unique human-readable name of the Resource.
5583        '''
5584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5585        '''
5586         ID of the secret store containing credentials for this resource, if any.
5587        '''
5588        self.service_account_key = service_account_key if service_account_key is not None else ''
5589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5590        '''
5591         Tags is a map of key, value pairs.
5592        '''
5593
5594    def __repr__(self):
5595        return '<sdm.GoogleGKEUserImpersonation ' + \
5596            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5597            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5598            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5599            'endpoint: ' + repr(self.endpoint) + ' ' +\
5600            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5601            'healthy: ' + repr(self.healthy) + ' ' +\
5602            'id: ' + repr(self.id) + ' ' +\
5603            'name: ' + repr(self.name) + ' ' +\
5604            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5605            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5606            'tags: ' + repr(self.tags) + ' ' +\
5607            '>'
5608
5609    def to_dict(self):
5610        return {
5611            'bind_interface': self.bind_interface,
5612            'certificate_authority': self.certificate_authority,
5613            'egress_filter': self.egress_filter,
5614            'endpoint': self.endpoint,
5615            'healthcheck_namespace': self.healthcheck_namespace,
5616            'healthy': self.healthy,
5617            'id': self.id,
5618            'name': self.name,
5619            'secret_store_id': self.secret_store_id,
5620            'service_account_key': self.service_account_key,
5621            'tags': self.tags,
5622        }
5623
5624    @classmethod
5625    def from_dict(cls, d):
5626        return cls(
5627            bind_interface=d.get('bind_interface'),
5628            certificate_authority=d.get('certificate_authority'),
5629            egress_filter=d.get('egress_filter'),
5630            endpoint=d.get('endpoint'),
5631            healthcheck_namespace=d.get('healthcheck_namespace'),
5632            healthy=d.get('healthy'),
5633            id=d.get('id'),
5634            name=d.get('name'),
5635            secret_store_id=d.get('secret_store_id'),
5636            service_account_key=d.get('service_account_key'),
5637            tags=d.get('tags'),
5638        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5544    def __init__(
5545        self,
5546        bind_interface=None,
5547        certificate_authority=None,
5548        egress_filter=None,
5549        endpoint=None,
5550        healthcheck_namespace=None,
5551        healthy=None,
5552        id=None,
5553        name=None,
5554        secret_store_id=None,
5555        service_account_key=None,
5556        tags=None,
5557    ):
5558        self.bind_interface = bind_interface if bind_interface is not None else ''
5559        '''
5560         Bind interface
5561        '''
5562        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5563        self.egress_filter = egress_filter if egress_filter is not None else ''
5564        '''
5565         A filter applied to the routing logic to pin datasource to nodes.
5566        '''
5567        self.endpoint = endpoint if endpoint is not None else ''
5568        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5569        '''
5570         The path used to check the health of your connection.  Defaults to `default`.
5571        '''
5572        self.healthy = healthy if healthy is not None else False
5573        '''
5574         True if the datasource is reachable and the credentials are valid.
5575        '''
5576        self.id = id if id is not None else ''
5577        '''
5578         Unique identifier of the Resource.
5579        '''
5580        self.name = name if name is not None else ''
5581        '''
5582         Unique human-readable name of the Resource.
5583        '''
5584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5585        '''
5586         ID of the secret store containing credentials for this resource, if any.
5587        '''
5588        self.service_account_key = service_account_key if service_account_key is not None else ''
5589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5590        '''
5591         Tags is a map of key, value pairs.
5592        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5609    def to_dict(self):
5610        return {
5611            'bind_interface': self.bind_interface,
5612            'certificate_authority': self.certificate_authority,
5613            'egress_filter': self.egress_filter,
5614            'endpoint': self.endpoint,
5615            'healthcheck_namespace': self.healthcheck_namespace,
5616            'healthy': self.healthy,
5617            'id': self.id,
5618            'name': self.name,
5619            'secret_store_id': self.secret_store_id,
5620            'service_account_key': self.service_account_key,
5621            'tags': self.tags,
5622        }
@classmethod
def from_dict(cls, d)
5624    @classmethod
5625    def from_dict(cls, d):
5626        return cls(
5627            bind_interface=d.get('bind_interface'),
5628            certificate_authority=d.get('certificate_authority'),
5629            egress_filter=d.get('egress_filter'),
5630            endpoint=d.get('endpoint'),
5631            healthcheck_namespace=d.get('healthcheck_namespace'),
5632            healthy=d.get('healthy'),
5633            id=d.get('id'),
5634            name=d.get('name'),
5635            secret_store_id=d.get('secret_store_id'),
5636            service_account_key=d.get('service_account_key'),
5637            tags=d.get('tags'),
5638        )
class Greenplum:
5641class Greenplum:
5642    __slots__ = [
5643        'bind_interface',
5644        'database',
5645        'egress_filter',
5646        'healthy',
5647        'hostname',
5648        'id',
5649        'name',
5650        'override_database',
5651        'password',
5652        'port',
5653        'port_override',
5654        'secret_store_id',
5655        'tags',
5656        'username',
5657    ]
5658
5659    def __init__(
5660        self,
5661        bind_interface=None,
5662        database=None,
5663        egress_filter=None,
5664        healthy=None,
5665        hostname=None,
5666        id=None,
5667        name=None,
5668        override_database=None,
5669        password=None,
5670        port=None,
5671        port_override=None,
5672        secret_store_id=None,
5673        tags=None,
5674        username=None,
5675    ):
5676        self.bind_interface = bind_interface if bind_interface is not None else ''
5677        '''
5678         Bind interface
5679        '''
5680        self.database = database if database is not None else ''
5681        self.egress_filter = egress_filter if egress_filter is not None else ''
5682        '''
5683         A filter applied to the routing logic to pin datasource to nodes.
5684        '''
5685        self.healthy = healthy if healthy is not None else False
5686        '''
5687         True if the datasource is reachable and the credentials are valid.
5688        '''
5689        self.hostname = hostname if hostname is not None else ''
5690        self.id = id if id is not None else ''
5691        '''
5692         Unique identifier of the Resource.
5693        '''
5694        self.name = name if name is not None else ''
5695        '''
5696         Unique human-readable name of the Resource.
5697        '''
5698        self.override_database = override_database if override_database is not None else False
5699        self.password = password if password is not None else ''
5700        self.port = port if port is not None else 0
5701        self.port_override = port_override if port_override is not None else 0
5702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5703        '''
5704         ID of the secret store containing credentials for this resource, if any.
5705        '''
5706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5707        '''
5708         Tags is a map of key, value pairs.
5709        '''
5710        self.username = username if username is not None else ''
5711
5712    def __repr__(self):
5713        return '<sdm.Greenplum ' + \
5714            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5715            'database: ' + repr(self.database) + ' ' +\
5716            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5717            'healthy: ' + repr(self.healthy) + ' ' +\
5718            'hostname: ' + repr(self.hostname) + ' ' +\
5719            'id: ' + repr(self.id) + ' ' +\
5720            'name: ' + repr(self.name) + ' ' +\
5721            'override_database: ' + repr(self.override_database) + ' ' +\
5722            'password: ' + repr(self.password) + ' ' +\
5723            'port: ' + repr(self.port) + ' ' +\
5724            'port_override: ' + repr(self.port_override) + ' ' +\
5725            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5726            'tags: ' + repr(self.tags) + ' ' +\
5727            'username: ' + repr(self.username) + ' ' +\
5728            '>'
5729
5730    def to_dict(self):
5731        return {
5732            'bind_interface': self.bind_interface,
5733            'database': self.database,
5734            'egress_filter': self.egress_filter,
5735            'healthy': self.healthy,
5736            'hostname': self.hostname,
5737            'id': self.id,
5738            'name': self.name,
5739            'override_database': self.override_database,
5740            'password': self.password,
5741            'port': self.port,
5742            'port_override': self.port_override,
5743            'secret_store_id': self.secret_store_id,
5744            'tags': self.tags,
5745            'username': self.username,
5746        }
5747
5748    @classmethod
5749    def from_dict(cls, d):
5750        return cls(
5751            bind_interface=d.get('bind_interface'),
5752            database=d.get('database'),
5753            egress_filter=d.get('egress_filter'),
5754            healthy=d.get('healthy'),
5755            hostname=d.get('hostname'),
5756            id=d.get('id'),
5757            name=d.get('name'),
5758            override_database=d.get('override_database'),
5759            password=d.get('password'),
5760            port=d.get('port'),
5761            port_override=d.get('port_override'),
5762            secret_store_id=d.get('secret_store_id'),
5763            tags=d.get('tags'),
5764            username=d.get('username'),
5765        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5659    def __init__(
5660        self,
5661        bind_interface=None,
5662        database=None,
5663        egress_filter=None,
5664        healthy=None,
5665        hostname=None,
5666        id=None,
5667        name=None,
5668        override_database=None,
5669        password=None,
5670        port=None,
5671        port_override=None,
5672        secret_store_id=None,
5673        tags=None,
5674        username=None,
5675    ):
5676        self.bind_interface = bind_interface if bind_interface is not None else ''
5677        '''
5678         Bind interface
5679        '''
5680        self.database = database if database is not None else ''
5681        self.egress_filter = egress_filter if egress_filter is not None else ''
5682        '''
5683         A filter applied to the routing logic to pin datasource to nodes.
5684        '''
5685        self.healthy = healthy if healthy is not None else False
5686        '''
5687         True if the datasource is reachable and the credentials are valid.
5688        '''
5689        self.hostname = hostname if hostname is not None else ''
5690        self.id = id if id is not None else ''
5691        '''
5692         Unique identifier of the Resource.
5693        '''
5694        self.name = name if name is not None else ''
5695        '''
5696         Unique human-readable name of the Resource.
5697        '''
5698        self.override_database = override_database if override_database is not None else False
5699        self.password = password if password is not None else ''
5700        self.port = port if port is not None else 0
5701        self.port_override = port_override if port_override is not None else 0
5702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5703        '''
5704         ID of the secret store containing credentials for this resource, if any.
5705        '''
5706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5707        '''
5708         Tags is a map of key, value pairs.
5709        '''
5710        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5730    def to_dict(self):
5731        return {
5732            'bind_interface': self.bind_interface,
5733            'database': self.database,
5734            'egress_filter': self.egress_filter,
5735            'healthy': self.healthy,
5736            'hostname': self.hostname,
5737            'id': self.id,
5738            'name': self.name,
5739            'override_database': self.override_database,
5740            'password': self.password,
5741            'port': self.port,
5742            'port_override': self.port_override,
5743            'secret_store_id': self.secret_store_id,
5744            'tags': self.tags,
5745            'username': self.username,
5746        }
@classmethod
def from_dict(cls, d)
5748    @classmethod
5749    def from_dict(cls, d):
5750        return cls(
5751            bind_interface=d.get('bind_interface'),
5752            database=d.get('database'),
5753            egress_filter=d.get('egress_filter'),
5754            healthy=d.get('healthy'),
5755            hostname=d.get('hostname'),
5756            id=d.get('id'),
5757            name=d.get('name'),
5758            override_database=d.get('override_database'),
5759            password=d.get('password'),
5760            port=d.get('port'),
5761            port_override=d.get('port_override'),
5762            secret_store_id=d.get('secret_store_id'),
5763            tags=d.get('tags'),
5764            username=d.get('username'),
5765        )
class HTTPAuth:
5768class HTTPAuth:
5769    __slots__ = [
5770        'auth_header',
5771        'bind_interface',
5772        'default_path',
5773        'egress_filter',
5774        'headers_blacklist',
5775        'healthcheck_path',
5776        'healthy',
5777        'host_override',
5778        'id',
5779        'name',
5780        'secret_store_id',
5781        'subdomain',
5782        'tags',
5783        'url',
5784    ]
5785
5786    def __init__(
5787        self,
5788        auth_header=None,
5789        bind_interface=None,
5790        default_path=None,
5791        egress_filter=None,
5792        headers_blacklist=None,
5793        healthcheck_path=None,
5794        healthy=None,
5795        host_override=None,
5796        id=None,
5797        name=None,
5798        secret_store_id=None,
5799        subdomain=None,
5800        tags=None,
5801        url=None,
5802    ):
5803        self.auth_header = auth_header if auth_header is not None else ''
5804        self.bind_interface = bind_interface if bind_interface is not None else ''
5805        '''
5806         Bind interface
5807        '''
5808        self.default_path = default_path if default_path is not None else ''
5809        self.egress_filter = egress_filter if egress_filter is not None else ''
5810        '''
5811         A filter applied to the routing logic to pin datasource to nodes.
5812        '''
5813        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5814        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5815        self.healthy = healthy if healthy is not None else False
5816        '''
5817         True if the datasource is reachable and the credentials are valid.
5818        '''
5819        self.host_override = host_override if host_override is not None else ''
5820        self.id = id if id is not None else ''
5821        '''
5822         Unique identifier of the Resource.
5823        '''
5824        self.name = name if name is not None else ''
5825        '''
5826         Unique human-readable name of the Resource.
5827        '''
5828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5829        '''
5830         ID of the secret store containing credentials for this resource, if any.
5831        '''
5832        self.subdomain = subdomain if subdomain is not None else ''
5833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5834        '''
5835         Tags is a map of key, value pairs.
5836        '''
5837        self.url = url if url is not None else ''
5838
5839    def __repr__(self):
5840        return '<sdm.HTTPAuth ' + \
5841            'auth_header: ' + repr(self.auth_header) + ' ' +\
5842            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5843            'default_path: ' + repr(self.default_path) + ' ' +\
5844            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5845            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5846            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5847            'healthy: ' + repr(self.healthy) + ' ' +\
5848            'host_override: ' + repr(self.host_override) + ' ' +\
5849            'id: ' + repr(self.id) + ' ' +\
5850            'name: ' + repr(self.name) + ' ' +\
5851            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5852            'subdomain: ' + repr(self.subdomain) + ' ' +\
5853            'tags: ' + repr(self.tags) + ' ' +\
5854            'url: ' + repr(self.url) + ' ' +\
5855            '>'
5856
5857    def to_dict(self):
5858        return {
5859            'auth_header': self.auth_header,
5860            'bind_interface': self.bind_interface,
5861            'default_path': self.default_path,
5862            'egress_filter': self.egress_filter,
5863            'headers_blacklist': self.headers_blacklist,
5864            'healthcheck_path': self.healthcheck_path,
5865            'healthy': self.healthy,
5866            'host_override': self.host_override,
5867            'id': self.id,
5868            'name': self.name,
5869            'secret_store_id': self.secret_store_id,
5870            'subdomain': self.subdomain,
5871            'tags': self.tags,
5872            'url': self.url,
5873        }
5874
5875    @classmethod
5876    def from_dict(cls, d):
5877        return cls(
5878            auth_header=d.get('auth_header'),
5879            bind_interface=d.get('bind_interface'),
5880            default_path=d.get('default_path'),
5881            egress_filter=d.get('egress_filter'),
5882            headers_blacklist=d.get('headers_blacklist'),
5883            healthcheck_path=d.get('healthcheck_path'),
5884            healthy=d.get('healthy'),
5885            host_override=d.get('host_override'),
5886            id=d.get('id'),
5887            name=d.get('name'),
5888            secret_store_id=d.get('secret_store_id'),
5889            subdomain=d.get('subdomain'),
5890            tags=d.get('tags'),
5891            url=d.get('url'),
5892        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5786    def __init__(
5787        self,
5788        auth_header=None,
5789        bind_interface=None,
5790        default_path=None,
5791        egress_filter=None,
5792        headers_blacklist=None,
5793        healthcheck_path=None,
5794        healthy=None,
5795        host_override=None,
5796        id=None,
5797        name=None,
5798        secret_store_id=None,
5799        subdomain=None,
5800        tags=None,
5801        url=None,
5802    ):
5803        self.auth_header = auth_header if auth_header is not None else ''
5804        self.bind_interface = bind_interface if bind_interface is not None else ''
5805        '''
5806         Bind interface
5807        '''
5808        self.default_path = default_path if default_path is not None else ''
5809        self.egress_filter = egress_filter if egress_filter is not None else ''
5810        '''
5811         A filter applied to the routing logic to pin datasource to nodes.
5812        '''
5813        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5814        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5815        self.healthy = healthy if healthy is not None else False
5816        '''
5817         True if the datasource is reachable and the credentials are valid.
5818        '''
5819        self.host_override = host_override if host_override is not None else ''
5820        self.id = id if id is not None else ''
5821        '''
5822         Unique identifier of the Resource.
5823        '''
5824        self.name = name if name is not None else ''
5825        '''
5826         Unique human-readable name of the Resource.
5827        '''
5828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5829        '''
5830         ID of the secret store containing credentials for this resource, if any.
5831        '''
5832        self.subdomain = subdomain if subdomain is not None else ''
5833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5834        '''
5835         Tags is a map of key, value pairs.
5836        '''
5837        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5857    def to_dict(self):
5858        return {
5859            'auth_header': self.auth_header,
5860            'bind_interface': self.bind_interface,
5861            'default_path': self.default_path,
5862            'egress_filter': self.egress_filter,
5863            'headers_blacklist': self.headers_blacklist,
5864            'healthcheck_path': self.healthcheck_path,
5865            'healthy': self.healthy,
5866            'host_override': self.host_override,
5867            'id': self.id,
5868            'name': self.name,
5869            'secret_store_id': self.secret_store_id,
5870            'subdomain': self.subdomain,
5871            'tags': self.tags,
5872            'url': self.url,
5873        }
@classmethod
def from_dict(cls, d)
5875    @classmethod
5876    def from_dict(cls, d):
5877        return cls(
5878            auth_header=d.get('auth_header'),
5879            bind_interface=d.get('bind_interface'),
5880            default_path=d.get('default_path'),
5881            egress_filter=d.get('egress_filter'),
5882            headers_blacklist=d.get('headers_blacklist'),
5883            healthcheck_path=d.get('healthcheck_path'),
5884            healthy=d.get('healthy'),
5885            host_override=d.get('host_override'),
5886            id=d.get('id'),
5887            name=d.get('name'),
5888            secret_store_id=d.get('secret_store_id'),
5889            subdomain=d.get('subdomain'),
5890            tags=d.get('tags'),
5891            url=d.get('url'),
5892        )
class HTTPBasicAuth:
5895class HTTPBasicAuth:
5896    __slots__ = [
5897        'bind_interface',
5898        'default_path',
5899        'egress_filter',
5900        'headers_blacklist',
5901        'healthcheck_path',
5902        'healthy',
5903        'host_override',
5904        'id',
5905        'name',
5906        'password',
5907        'secret_store_id',
5908        'subdomain',
5909        'tags',
5910        'url',
5911        'username',
5912    ]
5913
5914    def __init__(
5915        self,
5916        bind_interface=None,
5917        default_path=None,
5918        egress_filter=None,
5919        headers_blacklist=None,
5920        healthcheck_path=None,
5921        healthy=None,
5922        host_override=None,
5923        id=None,
5924        name=None,
5925        password=None,
5926        secret_store_id=None,
5927        subdomain=None,
5928        tags=None,
5929        url=None,
5930        username=None,
5931    ):
5932        self.bind_interface = bind_interface if bind_interface is not None else ''
5933        '''
5934         Bind interface
5935        '''
5936        self.default_path = default_path if default_path is not None else ''
5937        self.egress_filter = egress_filter if egress_filter is not None else ''
5938        '''
5939         A filter applied to the routing logic to pin datasource to nodes.
5940        '''
5941        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5942        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5943        self.healthy = healthy if healthy is not None else False
5944        '''
5945         True if the datasource is reachable and the credentials are valid.
5946        '''
5947        self.host_override = host_override if host_override is not None else ''
5948        self.id = id if id is not None else ''
5949        '''
5950         Unique identifier of the Resource.
5951        '''
5952        self.name = name if name is not None else ''
5953        '''
5954         Unique human-readable name of the Resource.
5955        '''
5956        self.password = password if password is not None else ''
5957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5958        '''
5959         ID of the secret store containing credentials for this resource, if any.
5960        '''
5961        self.subdomain = subdomain if subdomain is not None else ''
5962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5963        '''
5964         Tags is a map of key, value pairs.
5965        '''
5966        self.url = url if url is not None else ''
5967        self.username = username if username is not None else ''
5968
5969    def __repr__(self):
5970        return '<sdm.HTTPBasicAuth ' + \
5971            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5972            'default_path: ' + repr(self.default_path) + ' ' +\
5973            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5974            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5975            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5976            'healthy: ' + repr(self.healthy) + ' ' +\
5977            'host_override: ' + repr(self.host_override) + ' ' +\
5978            'id: ' + repr(self.id) + ' ' +\
5979            'name: ' + repr(self.name) + ' ' +\
5980            'password: ' + repr(self.password) + ' ' +\
5981            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5982            'subdomain: ' + repr(self.subdomain) + ' ' +\
5983            'tags: ' + repr(self.tags) + ' ' +\
5984            'url: ' + repr(self.url) + ' ' +\
5985            'username: ' + repr(self.username) + ' ' +\
5986            '>'
5987
5988    def to_dict(self):
5989        return {
5990            'bind_interface': self.bind_interface,
5991            'default_path': self.default_path,
5992            'egress_filter': self.egress_filter,
5993            'headers_blacklist': self.headers_blacklist,
5994            'healthcheck_path': self.healthcheck_path,
5995            'healthy': self.healthy,
5996            'host_override': self.host_override,
5997            'id': self.id,
5998            'name': self.name,
5999            'password': self.password,
6000            'secret_store_id': self.secret_store_id,
6001            'subdomain': self.subdomain,
6002            'tags': self.tags,
6003            'url': self.url,
6004            'username': self.username,
6005        }
6006
6007    @classmethod
6008    def from_dict(cls, d):
6009        return cls(
6010            bind_interface=d.get('bind_interface'),
6011            default_path=d.get('default_path'),
6012            egress_filter=d.get('egress_filter'),
6013            headers_blacklist=d.get('headers_blacklist'),
6014            healthcheck_path=d.get('healthcheck_path'),
6015            healthy=d.get('healthy'),
6016            host_override=d.get('host_override'),
6017            id=d.get('id'),
6018            name=d.get('name'),
6019            password=d.get('password'),
6020            secret_store_id=d.get('secret_store_id'),
6021            subdomain=d.get('subdomain'),
6022            tags=d.get('tags'),
6023            url=d.get('url'),
6024            username=d.get('username'),
6025        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5914    def __init__(
5915        self,
5916        bind_interface=None,
5917        default_path=None,
5918        egress_filter=None,
5919        headers_blacklist=None,
5920        healthcheck_path=None,
5921        healthy=None,
5922        host_override=None,
5923        id=None,
5924        name=None,
5925        password=None,
5926        secret_store_id=None,
5927        subdomain=None,
5928        tags=None,
5929        url=None,
5930        username=None,
5931    ):
5932        self.bind_interface = bind_interface if bind_interface is not None else ''
5933        '''
5934         Bind interface
5935        '''
5936        self.default_path = default_path if default_path is not None else ''
5937        self.egress_filter = egress_filter if egress_filter is not None else ''
5938        '''
5939         A filter applied to the routing logic to pin datasource to nodes.
5940        '''
5941        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5942        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5943        self.healthy = healthy if healthy is not None else False
5944        '''
5945         True if the datasource is reachable and the credentials are valid.
5946        '''
5947        self.host_override = host_override if host_override is not None else ''
5948        self.id = id if id is not None else ''
5949        '''
5950         Unique identifier of the Resource.
5951        '''
5952        self.name = name if name is not None else ''
5953        '''
5954         Unique human-readable name of the Resource.
5955        '''
5956        self.password = password if password is not None else ''
5957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5958        '''
5959         ID of the secret store containing credentials for this resource, if any.
5960        '''
5961        self.subdomain = subdomain if subdomain is not None else ''
5962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5963        '''
5964         Tags is a map of key, value pairs.
5965        '''
5966        self.url = url if url is not None else ''
5967        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
5988    def to_dict(self):
5989        return {
5990            'bind_interface': self.bind_interface,
5991            'default_path': self.default_path,
5992            'egress_filter': self.egress_filter,
5993            'headers_blacklist': self.headers_blacklist,
5994            'healthcheck_path': self.healthcheck_path,
5995            'healthy': self.healthy,
5996            'host_override': self.host_override,
5997            'id': self.id,
5998            'name': self.name,
5999            'password': self.password,
6000            'secret_store_id': self.secret_store_id,
6001            'subdomain': self.subdomain,
6002            'tags': self.tags,
6003            'url': self.url,
6004            'username': self.username,
6005        }
@classmethod
def from_dict(cls, d)
6007    @classmethod
6008    def from_dict(cls, d):
6009        return cls(
6010            bind_interface=d.get('bind_interface'),
6011            default_path=d.get('default_path'),
6012            egress_filter=d.get('egress_filter'),
6013            headers_blacklist=d.get('headers_blacklist'),
6014            healthcheck_path=d.get('healthcheck_path'),
6015            healthy=d.get('healthy'),
6016            host_override=d.get('host_override'),
6017            id=d.get('id'),
6018            name=d.get('name'),
6019            password=d.get('password'),
6020            secret_store_id=d.get('secret_store_id'),
6021            subdomain=d.get('subdomain'),
6022            tags=d.get('tags'),
6023            url=d.get('url'),
6024            username=d.get('username'),
6025        )
class HTTPNoAuth:
6028class HTTPNoAuth:
6029    __slots__ = [
6030        'bind_interface',
6031        'default_path',
6032        'egress_filter',
6033        'headers_blacklist',
6034        'healthcheck_path',
6035        'healthy',
6036        'host_override',
6037        'id',
6038        'name',
6039        'secret_store_id',
6040        'subdomain',
6041        'tags',
6042        'url',
6043    ]
6044
6045    def __init__(
6046        self,
6047        bind_interface=None,
6048        default_path=None,
6049        egress_filter=None,
6050        headers_blacklist=None,
6051        healthcheck_path=None,
6052        healthy=None,
6053        host_override=None,
6054        id=None,
6055        name=None,
6056        secret_store_id=None,
6057        subdomain=None,
6058        tags=None,
6059        url=None,
6060    ):
6061        self.bind_interface = bind_interface if bind_interface is not None else ''
6062        '''
6063         Bind interface
6064        '''
6065        self.default_path = default_path if default_path is not None else ''
6066        self.egress_filter = egress_filter if egress_filter is not None else ''
6067        '''
6068         A filter applied to the routing logic to pin datasource to nodes.
6069        '''
6070        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6071        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6072        self.healthy = healthy if healthy is not None else False
6073        '''
6074         True if the datasource is reachable and the credentials are valid.
6075        '''
6076        self.host_override = host_override if host_override is not None else ''
6077        self.id = id if id is not None else ''
6078        '''
6079         Unique identifier of the Resource.
6080        '''
6081        self.name = name if name is not None else ''
6082        '''
6083         Unique human-readable name of the Resource.
6084        '''
6085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6086        '''
6087         ID of the secret store containing credentials for this resource, if any.
6088        '''
6089        self.subdomain = subdomain if subdomain is not None else ''
6090        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6091        '''
6092         Tags is a map of key, value pairs.
6093        '''
6094        self.url = url if url is not None else ''
6095
6096    def __repr__(self):
6097        return '<sdm.HTTPNoAuth ' + \
6098            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6099            'default_path: ' + repr(self.default_path) + ' ' +\
6100            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6101            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6102            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6103            'healthy: ' + repr(self.healthy) + ' ' +\
6104            'host_override: ' + repr(self.host_override) + ' ' +\
6105            'id: ' + repr(self.id) + ' ' +\
6106            'name: ' + repr(self.name) + ' ' +\
6107            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6108            'subdomain: ' + repr(self.subdomain) + ' ' +\
6109            'tags: ' + repr(self.tags) + ' ' +\
6110            'url: ' + repr(self.url) + ' ' +\
6111            '>'
6112
6113    def to_dict(self):
6114        return {
6115            'bind_interface': self.bind_interface,
6116            'default_path': self.default_path,
6117            'egress_filter': self.egress_filter,
6118            'headers_blacklist': self.headers_blacklist,
6119            'healthcheck_path': self.healthcheck_path,
6120            'healthy': self.healthy,
6121            'host_override': self.host_override,
6122            'id': self.id,
6123            'name': self.name,
6124            'secret_store_id': self.secret_store_id,
6125            'subdomain': self.subdomain,
6126            'tags': self.tags,
6127            'url': self.url,
6128        }
6129
6130    @classmethod
6131    def from_dict(cls, d):
6132        return cls(
6133            bind_interface=d.get('bind_interface'),
6134            default_path=d.get('default_path'),
6135            egress_filter=d.get('egress_filter'),
6136            headers_blacklist=d.get('headers_blacklist'),
6137            healthcheck_path=d.get('healthcheck_path'),
6138            healthy=d.get('healthy'),
6139            host_override=d.get('host_override'),
6140            id=d.get('id'),
6141            name=d.get('name'),
6142            secret_store_id=d.get('secret_store_id'),
6143            subdomain=d.get('subdomain'),
6144            tags=d.get('tags'),
6145            url=d.get('url'),
6146        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6045    def __init__(
6046        self,
6047        bind_interface=None,
6048        default_path=None,
6049        egress_filter=None,
6050        headers_blacklist=None,
6051        healthcheck_path=None,
6052        healthy=None,
6053        host_override=None,
6054        id=None,
6055        name=None,
6056        secret_store_id=None,
6057        subdomain=None,
6058        tags=None,
6059        url=None,
6060    ):
6061        self.bind_interface = bind_interface if bind_interface is not None else ''
6062        '''
6063         Bind interface
6064        '''
6065        self.default_path = default_path if default_path is not None else ''
6066        self.egress_filter = egress_filter if egress_filter is not None else ''
6067        '''
6068         A filter applied to the routing logic to pin datasource to nodes.
6069        '''
6070        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6071        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6072        self.healthy = healthy if healthy is not None else False
6073        '''
6074         True if the datasource is reachable and the credentials are valid.
6075        '''
6076        self.host_override = host_override if host_override is not None else ''
6077        self.id = id if id is not None else ''
6078        '''
6079         Unique identifier of the Resource.
6080        '''
6081        self.name = name if name is not None else ''
6082        '''
6083         Unique human-readable name of the Resource.
6084        '''
6085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6086        '''
6087         ID of the secret store containing credentials for this resource, if any.
6088        '''
6089        self.subdomain = subdomain if subdomain is not None else ''
6090        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6091        '''
6092         Tags is a map of key, value pairs.
6093        '''
6094        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6113    def to_dict(self):
6114        return {
6115            'bind_interface': self.bind_interface,
6116            'default_path': self.default_path,
6117            'egress_filter': self.egress_filter,
6118            'headers_blacklist': self.headers_blacklist,
6119            'healthcheck_path': self.healthcheck_path,
6120            'healthy': self.healthy,
6121            'host_override': self.host_override,
6122            'id': self.id,
6123            'name': self.name,
6124            'secret_store_id': self.secret_store_id,
6125            'subdomain': self.subdomain,
6126            'tags': self.tags,
6127            'url': self.url,
6128        }
@classmethod
def from_dict(cls, d)
6130    @classmethod
6131    def from_dict(cls, d):
6132        return cls(
6133            bind_interface=d.get('bind_interface'),
6134            default_path=d.get('default_path'),
6135            egress_filter=d.get('egress_filter'),
6136            headers_blacklist=d.get('headers_blacklist'),
6137            healthcheck_path=d.get('healthcheck_path'),
6138            healthy=d.get('healthy'),
6139            host_override=d.get('host_override'),
6140            id=d.get('id'),
6141            name=d.get('name'),
6142            secret_store_id=d.get('secret_store_id'),
6143            subdomain=d.get('subdomain'),
6144            tags=d.get('tags'),
6145            url=d.get('url'),
6146        )
class Kubernetes:
6149class Kubernetes:
6150    __slots__ = [
6151        'bind_interface',
6152        'certificate_authority',
6153        'client_certificate',
6154        'client_key',
6155        'egress_filter',
6156        'healthcheck_namespace',
6157        'healthy',
6158        'hostname',
6159        'id',
6160        'name',
6161        'port',
6162        'port_override',
6163        'remote_identity_group_id',
6164        'remote_identity_healthcheck_username',
6165        'secret_store_id',
6166        'tags',
6167    ]
6168
6169    def __init__(
6170        self,
6171        bind_interface=None,
6172        certificate_authority=None,
6173        client_certificate=None,
6174        client_key=None,
6175        egress_filter=None,
6176        healthcheck_namespace=None,
6177        healthy=None,
6178        hostname=None,
6179        id=None,
6180        name=None,
6181        port=None,
6182        port_override=None,
6183        remote_identity_group_id=None,
6184        remote_identity_healthcheck_username=None,
6185        secret_store_id=None,
6186        tags=None,
6187    ):
6188        self.bind_interface = bind_interface if bind_interface is not None else ''
6189        '''
6190         Bind interface
6191        '''
6192        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6193        self.client_certificate = client_certificate if client_certificate is not None else ''
6194        self.client_key = client_key if client_key is not None else ''
6195        self.egress_filter = egress_filter if egress_filter is not None else ''
6196        '''
6197         A filter applied to the routing logic to pin datasource to nodes.
6198        '''
6199        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6200        '''
6201         The path used to check the health of your connection.  Defaults to `default`.
6202        '''
6203        self.healthy = healthy if healthy is not None else False
6204        '''
6205         True if the datasource is reachable and the credentials are valid.
6206        '''
6207        self.hostname = hostname if hostname is not None else ''
6208        self.id = id if id is not None else ''
6209        '''
6210         Unique identifier of the Resource.
6211        '''
6212        self.name = name if name is not None else ''
6213        '''
6214         Unique human-readable name of the Resource.
6215        '''
6216        self.port = port if port is not None else 0
6217        self.port_override = port_override if port_override is not None else 0
6218        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6219        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6220        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6221        '''
6222         ID of the secret store containing credentials for this resource, if any.
6223        '''
6224        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6225        '''
6226         Tags is a map of key, value pairs.
6227        '''
6228
6229    def __repr__(self):
6230        return '<sdm.Kubernetes ' + \
6231            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6232            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6233            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6234            'client_key: ' + repr(self.client_key) + ' ' +\
6235            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6236            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6237            'healthy: ' + repr(self.healthy) + ' ' +\
6238            'hostname: ' + repr(self.hostname) + ' ' +\
6239            'id: ' + repr(self.id) + ' ' +\
6240            'name: ' + repr(self.name) + ' ' +\
6241            'port: ' + repr(self.port) + ' ' +\
6242            'port_override: ' + repr(self.port_override) + ' ' +\
6243            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6244            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6245            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6246            'tags: ' + repr(self.tags) + ' ' +\
6247            '>'
6248
6249    def to_dict(self):
6250        return {
6251            'bind_interface': self.bind_interface,
6252            'certificate_authority': self.certificate_authority,
6253            'client_certificate': self.client_certificate,
6254            'client_key': self.client_key,
6255            'egress_filter': self.egress_filter,
6256            'healthcheck_namespace': self.healthcheck_namespace,
6257            'healthy': self.healthy,
6258            'hostname': self.hostname,
6259            'id': self.id,
6260            'name': self.name,
6261            'port': self.port,
6262            'port_override': self.port_override,
6263            'remote_identity_group_id': self.remote_identity_group_id,
6264            'remote_identity_healthcheck_username':
6265            self.remote_identity_healthcheck_username,
6266            'secret_store_id': self.secret_store_id,
6267            'tags': self.tags,
6268        }
6269
6270    @classmethod
6271    def from_dict(cls, d):
6272        return cls(
6273            bind_interface=d.get('bind_interface'),
6274            certificate_authority=d.get('certificate_authority'),
6275            client_certificate=d.get('client_certificate'),
6276            client_key=d.get('client_key'),
6277            egress_filter=d.get('egress_filter'),
6278            healthcheck_namespace=d.get('healthcheck_namespace'),
6279            healthy=d.get('healthy'),
6280            hostname=d.get('hostname'),
6281            id=d.get('id'),
6282            name=d.get('name'),
6283            port=d.get('port'),
6284            port_override=d.get('port_override'),
6285            remote_identity_group_id=d.get('remote_identity_group_id'),
6286            remote_identity_healthcheck_username=d.get(
6287                'remote_identity_healthcheck_username'),
6288            secret_store_id=d.get('secret_store_id'),
6289            tags=d.get('tags'),
6290        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6169    def __init__(
6170        self,
6171        bind_interface=None,
6172        certificate_authority=None,
6173        client_certificate=None,
6174        client_key=None,
6175        egress_filter=None,
6176        healthcheck_namespace=None,
6177        healthy=None,
6178        hostname=None,
6179        id=None,
6180        name=None,
6181        port=None,
6182        port_override=None,
6183        remote_identity_group_id=None,
6184        remote_identity_healthcheck_username=None,
6185        secret_store_id=None,
6186        tags=None,
6187    ):
6188        self.bind_interface = bind_interface if bind_interface is not None else ''
6189        '''
6190         Bind interface
6191        '''
6192        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6193        self.client_certificate = client_certificate if client_certificate is not None else ''
6194        self.client_key = client_key if client_key is not None else ''
6195        self.egress_filter = egress_filter if egress_filter is not None else ''
6196        '''
6197         A filter applied to the routing logic to pin datasource to nodes.
6198        '''
6199        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6200        '''
6201         The path used to check the health of your connection.  Defaults to `default`.
6202        '''
6203        self.healthy = healthy if healthy is not None else False
6204        '''
6205         True if the datasource is reachable and the credentials are valid.
6206        '''
6207        self.hostname = hostname if hostname is not None else ''
6208        self.id = id if id is not None else ''
6209        '''
6210         Unique identifier of the Resource.
6211        '''
6212        self.name = name if name is not None else ''
6213        '''
6214         Unique human-readable name of the Resource.
6215        '''
6216        self.port = port if port is not None else 0
6217        self.port_override = port_override if port_override is not None else 0
6218        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6219        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6220        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6221        '''
6222         ID of the secret store containing credentials for this resource, if any.
6223        '''
6224        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6225        '''
6226         Tags is a map of key, value pairs.
6227        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6249    def to_dict(self):
6250        return {
6251            'bind_interface': self.bind_interface,
6252            'certificate_authority': self.certificate_authority,
6253            'client_certificate': self.client_certificate,
6254            'client_key': self.client_key,
6255            'egress_filter': self.egress_filter,
6256            'healthcheck_namespace': self.healthcheck_namespace,
6257            'healthy': self.healthy,
6258            'hostname': self.hostname,
6259            'id': self.id,
6260            'name': self.name,
6261            'port': self.port,
6262            'port_override': self.port_override,
6263            'remote_identity_group_id': self.remote_identity_group_id,
6264            'remote_identity_healthcheck_username':
6265            self.remote_identity_healthcheck_username,
6266            'secret_store_id': self.secret_store_id,
6267            'tags': self.tags,
6268        }
@classmethod
def from_dict(cls, d)
6270    @classmethod
6271    def from_dict(cls, d):
6272        return cls(
6273            bind_interface=d.get('bind_interface'),
6274            certificate_authority=d.get('certificate_authority'),
6275            client_certificate=d.get('client_certificate'),
6276            client_key=d.get('client_key'),
6277            egress_filter=d.get('egress_filter'),
6278            healthcheck_namespace=d.get('healthcheck_namespace'),
6279            healthy=d.get('healthy'),
6280            hostname=d.get('hostname'),
6281            id=d.get('id'),
6282            name=d.get('name'),
6283            port=d.get('port'),
6284            port_override=d.get('port_override'),
6285            remote_identity_group_id=d.get('remote_identity_group_id'),
6286            remote_identity_healthcheck_username=d.get(
6287                'remote_identity_healthcheck_username'),
6288            secret_store_id=d.get('secret_store_id'),
6289            tags=d.get('tags'),
6290        )
class KubernetesBasicAuth:
6293class KubernetesBasicAuth:
6294    __slots__ = [
6295        'bind_interface',
6296        'egress_filter',
6297        'healthcheck_namespace',
6298        'healthy',
6299        'hostname',
6300        'id',
6301        'name',
6302        'password',
6303        'port',
6304        'port_override',
6305        'secret_store_id',
6306        'tags',
6307        'username',
6308    ]
6309
6310    def __init__(
6311        self,
6312        bind_interface=None,
6313        egress_filter=None,
6314        healthcheck_namespace=None,
6315        healthy=None,
6316        hostname=None,
6317        id=None,
6318        name=None,
6319        password=None,
6320        port=None,
6321        port_override=None,
6322        secret_store_id=None,
6323        tags=None,
6324        username=None,
6325    ):
6326        self.bind_interface = bind_interface if bind_interface is not None else ''
6327        '''
6328         Bind interface
6329        '''
6330        self.egress_filter = egress_filter if egress_filter is not None else ''
6331        '''
6332         A filter applied to the routing logic to pin datasource to nodes.
6333        '''
6334        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6335        '''
6336         The path used to check the health of your connection.  Defaults to `default`.
6337        '''
6338        self.healthy = healthy if healthy is not None else False
6339        '''
6340         True if the datasource is reachable and the credentials are valid.
6341        '''
6342        self.hostname = hostname if hostname is not None else ''
6343        self.id = id if id is not None else ''
6344        '''
6345         Unique identifier of the Resource.
6346        '''
6347        self.name = name if name is not None else ''
6348        '''
6349         Unique human-readable name of the Resource.
6350        '''
6351        self.password = password if password is not None else ''
6352        self.port = port if port is not None else 0
6353        self.port_override = port_override if port_override is not None else 0
6354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6355        '''
6356         ID of the secret store containing credentials for this resource, if any.
6357        '''
6358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6359        '''
6360         Tags is a map of key, value pairs.
6361        '''
6362        self.username = username if username is not None else ''
6363
6364    def __repr__(self):
6365        return '<sdm.KubernetesBasicAuth ' + \
6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6369            'healthy: ' + repr(self.healthy) + ' ' +\
6370            'hostname: ' + repr(self.hostname) + ' ' +\
6371            'id: ' + repr(self.id) + ' ' +\
6372            'name: ' + repr(self.name) + ' ' +\
6373            'password: ' + repr(self.password) + ' ' +\
6374            'port: ' + repr(self.port) + ' ' +\
6375            'port_override: ' + repr(self.port_override) + ' ' +\
6376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6377            'tags: ' + repr(self.tags) + ' ' +\
6378            'username: ' + repr(self.username) + ' ' +\
6379            '>'
6380
6381    def to_dict(self):
6382        return {
6383            'bind_interface': self.bind_interface,
6384            'egress_filter': self.egress_filter,
6385            'healthcheck_namespace': self.healthcheck_namespace,
6386            'healthy': self.healthy,
6387            'hostname': self.hostname,
6388            'id': self.id,
6389            'name': self.name,
6390            'password': self.password,
6391            'port': self.port,
6392            'port_override': self.port_override,
6393            'secret_store_id': self.secret_store_id,
6394            'tags': self.tags,
6395            'username': self.username,
6396        }
6397
6398    @classmethod
6399    def from_dict(cls, d):
6400        return cls(
6401            bind_interface=d.get('bind_interface'),
6402            egress_filter=d.get('egress_filter'),
6403            healthcheck_namespace=d.get('healthcheck_namespace'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            tags=d.get('tags'),
6413            username=d.get('username'),
6414        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6310    def __init__(
6311        self,
6312        bind_interface=None,
6313        egress_filter=None,
6314        healthcheck_namespace=None,
6315        healthy=None,
6316        hostname=None,
6317        id=None,
6318        name=None,
6319        password=None,
6320        port=None,
6321        port_override=None,
6322        secret_store_id=None,
6323        tags=None,
6324        username=None,
6325    ):
6326        self.bind_interface = bind_interface if bind_interface is not None else ''
6327        '''
6328         Bind interface
6329        '''
6330        self.egress_filter = egress_filter if egress_filter is not None else ''
6331        '''
6332         A filter applied to the routing logic to pin datasource to nodes.
6333        '''
6334        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6335        '''
6336         The path used to check the health of your connection.  Defaults to `default`.
6337        '''
6338        self.healthy = healthy if healthy is not None else False
6339        '''
6340         True if the datasource is reachable and the credentials are valid.
6341        '''
6342        self.hostname = hostname if hostname is not None else ''
6343        self.id = id if id is not None else ''
6344        '''
6345         Unique identifier of the Resource.
6346        '''
6347        self.name = name if name is not None else ''
6348        '''
6349         Unique human-readable name of the Resource.
6350        '''
6351        self.password = password if password is not None else ''
6352        self.port = port if port is not None else 0
6353        self.port_override = port_override if port_override is not None else 0
6354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6355        '''
6356         ID of the secret store containing credentials for this resource, if any.
6357        '''
6358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6359        '''
6360         Tags is a map of key, value pairs.
6361        '''
6362        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6381    def to_dict(self):
6382        return {
6383            'bind_interface': self.bind_interface,
6384            'egress_filter': self.egress_filter,
6385            'healthcheck_namespace': self.healthcheck_namespace,
6386            'healthy': self.healthy,
6387            'hostname': self.hostname,
6388            'id': self.id,
6389            'name': self.name,
6390            'password': self.password,
6391            'port': self.port,
6392            'port_override': self.port_override,
6393            'secret_store_id': self.secret_store_id,
6394            'tags': self.tags,
6395            'username': self.username,
6396        }
@classmethod
def from_dict(cls, d)
6398    @classmethod
6399    def from_dict(cls, d):
6400        return cls(
6401            bind_interface=d.get('bind_interface'),
6402            egress_filter=d.get('egress_filter'),
6403            healthcheck_namespace=d.get('healthcheck_namespace'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            tags=d.get('tags'),
6413            username=d.get('username'),
6414        )
class KubernetesServiceAccount:
6417class KubernetesServiceAccount:
6418    __slots__ = [
6419        'bind_interface',
6420        'egress_filter',
6421        'healthcheck_namespace',
6422        'healthy',
6423        'hostname',
6424        'id',
6425        'name',
6426        'port',
6427        'port_override',
6428        'remote_identity_group_id',
6429        'remote_identity_healthcheck_username',
6430        'secret_store_id',
6431        'tags',
6432        'token',
6433    ]
6434
6435    def __init__(
6436        self,
6437        bind_interface=None,
6438        egress_filter=None,
6439        healthcheck_namespace=None,
6440        healthy=None,
6441        hostname=None,
6442        id=None,
6443        name=None,
6444        port=None,
6445        port_override=None,
6446        remote_identity_group_id=None,
6447        remote_identity_healthcheck_username=None,
6448        secret_store_id=None,
6449        tags=None,
6450        token=None,
6451    ):
6452        self.bind_interface = bind_interface if bind_interface is not None else ''
6453        '''
6454         Bind interface
6455        '''
6456        self.egress_filter = egress_filter if egress_filter is not None else ''
6457        '''
6458         A filter applied to the routing logic to pin datasource to nodes.
6459        '''
6460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6461        '''
6462         The path used to check the health of your connection.  Defaults to `default`.
6463        '''
6464        self.healthy = healthy if healthy is not None else False
6465        '''
6466         True if the datasource is reachable and the credentials are valid.
6467        '''
6468        self.hostname = hostname if hostname is not None else ''
6469        self.id = id if id is not None else ''
6470        '''
6471         Unique identifier of the Resource.
6472        '''
6473        self.name = name if name is not None else ''
6474        '''
6475         Unique human-readable name of the Resource.
6476        '''
6477        self.port = port if port is not None else 0
6478        self.port_override = port_override if port_override is not None else 0
6479        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6480        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6482        '''
6483         ID of the secret store containing credentials for this resource, if any.
6484        '''
6485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6486        '''
6487         Tags is a map of key, value pairs.
6488        '''
6489        self.token = token if token is not None else ''
6490
6491    def __repr__(self):
6492        return '<sdm.KubernetesServiceAccount ' + \
6493            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6494            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6495            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6496            'healthy: ' + repr(self.healthy) + ' ' +\
6497            'hostname: ' + repr(self.hostname) + ' ' +\
6498            'id: ' + repr(self.id) + ' ' +\
6499            'name: ' + repr(self.name) + ' ' +\
6500            'port: ' + repr(self.port) + ' ' +\
6501            'port_override: ' + repr(self.port_override) + ' ' +\
6502            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6503            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6504            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6505            'tags: ' + repr(self.tags) + ' ' +\
6506            'token: ' + repr(self.token) + ' ' +\
6507            '>'
6508
6509    def to_dict(self):
6510        return {
6511            'bind_interface': self.bind_interface,
6512            'egress_filter': self.egress_filter,
6513            'healthcheck_namespace': self.healthcheck_namespace,
6514            'healthy': self.healthy,
6515            'hostname': self.hostname,
6516            'id': self.id,
6517            'name': self.name,
6518            'port': self.port,
6519            'port_override': self.port_override,
6520            'remote_identity_group_id': self.remote_identity_group_id,
6521            'remote_identity_healthcheck_username':
6522            self.remote_identity_healthcheck_username,
6523            'secret_store_id': self.secret_store_id,
6524            'tags': self.tags,
6525            'token': self.token,
6526        }
6527
6528    @classmethod
6529    def from_dict(cls, d):
6530        return cls(
6531            bind_interface=d.get('bind_interface'),
6532            egress_filter=d.get('egress_filter'),
6533            healthcheck_namespace=d.get('healthcheck_namespace'),
6534            healthy=d.get('healthy'),
6535            hostname=d.get('hostname'),
6536            id=d.get('id'),
6537            name=d.get('name'),
6538            port=d.get('port'),
6539            port_override=d.get('port_override'),
6540            remote_identity_group_id=d.get('remote_identity_group_id'),
6541            remote_identity_healthcheck_username=d.get(
6542                'remote_identity_healthcheck_username'),
6543            secret_store_id=d.get('secret_store_id'),
6544            tags=d.get('tags'),
6545            token=d.get('token'),
6546        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6435    def __init__(
6436        self,
6437        bind_interface=None,
6438        egress_filter=None,
6439        healthcheck_namespace=None,
6440        healthy=None,
6441        hostname=None,
6442        id=None,
6443        name=None,
6444        port=None,
6445        port_override=None,
6446        remote_identity_group_id=None,
6447        remote_identity_healthcheck_username=None,
6448        secret_store_id=None,
6449        tags=None,
6450        token=None,
6451    ):
6452        self.bind_interface = bind_interface if bind_interface is not None else ''
6453        '''
6454         Bind interface
6455        '''
6456        self.egress_filter = egress_filter if egress_filter is not None else ''
6457        '''
6458         A filter applied to the routing logic to pin datasource to nodes.
6459        '''
6460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6461        '''
6462         The path used to check the health of your connection.  Defaults to `default`.
6463        '''
6464        self.healthy = healthy if healthy is not None else False
6465        '''
6466         True if the datasource is reachable and the credentials are valid.
6467        '''
6468        self.hostname = hostname if hostname is not None else ''
6469        self.id = id if id is not None else ''
6470        '''
6471         Unique identifier of the Resource.
6472        '''
6473        self.name = name if name is not None else ''
6474        '''
6475         Unique human-readable name of the Resource.
6476        '''
6477        self.port = port if port is not None else 0
6478        self.port_override = port_override if port_override is not None else 0
6479        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6480        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6482        '''
6483         ID of the secret store containing credentials for this resource, if any.
6484        '''
6485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6486        '''
6487         Tags is a map of key, value pairs.
6488        '''
6489        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6509    def to_dict(self):
6510        return {
6511            'bind_interface': self.bind_interface,
6512            'egress_filter': self.egress_filter,
6513            'healthcheck_namespace': self.healthcheck_namespace,
6514            'healthy': self.healthy,
6515            'hostname': self.hostname,
6516            'id': self.id,
6517            'name': self.name,
6518            'port': self.port,
6519            'port_override': self.port_override,
6520            'remote_identity_group_id': self.remote_identity_group_id,
6521            'remote_identity_healthcheck_username':
6522            self.remote_identity_healthcheck_username,
6523            'secret_store_id': self.secret_store_id,
6524            'tags': self.tags,
6525            'token': self.token,
6526        }
@classmethod
def from_dict(cls, d)
6528    @classmethod
6529    def from_dict(cls, d):
6530        return cls(
6531            bind_interface=d.get('bind_interface'),
6532            egress_filter=d.get('egress_filter'),
6533            healthcheck_namespace=d.get('healthcheck_namespace'),
6534            healthy=d.get('healthy'),
6535            hostname=d.get('hostname'),
6536            id=d.get('id'),
6537            name=d.get('name'),
6538            port=d.get('port'),
6539            port_override=d.get('port_override'),
6540            remote_identity_group_id=d.get('remote_identity_group_id'),
6541            remote_identity_healthcheck_username=d.get(
6542                'remote_identity_healthcheck_username'),
6543            secret_store_id=d.get('secret_store_id'),
6544            tags=d.get('tags'),
6545            token=d.get('token'),
6546        )
class KubernetesServiceAccountUserImpersonation:
6549class KubernetesServiceAccountUserImpersonation:
6550    __slots__ = [
6551        'bind_interface',
6552        'egress_filter',
6553        'healthcheck_namespace',
6554        'healthy',
6555        'hostname',
6556        'id',
6557        'name',
6558        'port',
6559        'port_override',
6560        'secret_store_id',
6561        'tags',
6562        'token',
6563    ]
6564
6565    def __init__(
6566        self,
6567        bind_interface=None,
6568        egress_filter=None,
6569        healthcheck_namespace=None,
6570        healthy=None,
6571        hostname=None,
6572        id=None,
6573        name=None,
6574        port=None,
6575        port_override=None,
6576        secret_store_id=None,
6577        tags=None,
6578        token=None,
6579    ):
6580        self.bind_interface = bind_interface if bind_interface is not None else ''
6581        '''
6582         Bind interface
6583        '''
6584        self.egress_filter = egress_filter if egress_filter is not None else ''
6585        '''
6586         A filter applied to the routing logic to pin datasource to nodes.
6587        '''
6588        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6589        '''
6590         The path used to check the health of your connection.  Defaults to `default`.
6591        '''
6592        self.healthy = healthy if healthy is not None else False
6593        '''
6594         True if the datasource is reachable and the credentials are valid.
6595        '''
6596        self.hostname = hostname if hostname is not None else ''
6597        self.id = id if id is not None else ''
6598        '''
6599         Unique identifier of the Resource.
6600        '''
6601        self.name = name if name is not None else ''
6602        '''
6603         Unique human-readable name of the Resource.
6604        '''
6605        self.port = port if port is not None else 0
6606        self.port_override = port_override if port_override is not None else 0
6607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6608        '''
6609         ID of the secret store containing credentials for this resource, if any.
6610        '''
6611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6612        '''
6613         Tags is a map of key, value pairs.
6614        '''
6615        self.token = token if token is not None else ''
6616
6617    def __repr__(self):
6618        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6619            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6622            'healthy: ' + repr(self.healthy) + ' ' +\
6623            'hostname: ' + repr(self.hostname) + ' ' +\
6624            'id: ' + repr(self.id) + ' ' +\
6625            'name: ' + repr(self.name) + ' ' +\
6626            'port: ' + repr(self.port) + ' ' +\
6627            'port_override: ' + repr(self.port_override) + ' ' +\
6628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6629            'tags: ' + repr(self.tags) + ' ' +\
6630            'token: ' + repr(self.token) + ' ' +\
6631            '>'
6632
6633    def to_dict(self):
6634        return {
6635            'bind_interface': self.bind_interface,
6636            'egress_filter': self.egress_filter,
6637            'healthcheck_namespace': self.healthcheck_namespace,
6638            'healthy': self.healthy,
6639            'hostname': self.hostname,
6640            'id': self.id,
6641            'name': self.name,
6642            'port': self.port,
6643            'port_override': self.port_override,
6644            'secret_store_id': self.secret_store_id,
6645            'tags': self.tags,
6646            'token': self.token,
6647        }
6648
6649    @classmethod
6650    def from_dict(cls, d):
6651        return cls(
6652            bind_interface=d.get('bind_interface'),
6653            egress_filter=d.get('egress_filter'),
6654            healthcheck_namespace=d.get('healthcheck_namespace'),
6655            healthy=d.get('healthy'),
6656            hostname=d.get('hostname'),
6657            id=d.get('id'),
6658            name=d.get('name'),
6659            port=d.get('port'),
6660            port_override=d.get('port_override'),
6661            secret_store_id=d.get('secret_store_id'),
6662            tags=d.get('tags'),
6663            token=d.get('token'),
6664        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6565    def __init__(
6566        self,
6567        bind_interface=None,
6568        egress_filter=None,
6569        healthcheck_namespace=None,
6570        healthy=None,
6571        hostname=None,
6572        id=None,
6573        name=None,
6574        port=None,
6575        port_override=None,
6576        secret_store_id=None,
6577        tags=None,
6578        token=None,
6579    ):
6580        self.bind_interface = bind_interface if bind_interface is not None else ''
6581        '''
6582         Bind interface
6583        '''
6584        self.egress_filter = egress_filter if egress_filter is not None else ''
6585        '''
6586         A filter applied to the routing logic to pin datasource to nodes.
6587        '''
6588        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6589        '''
6590         The path used to check the health of your connection.  Defaults to `default`.
6591        '''
6592        self.healthy = healthy if healthy is not None else False
6593        '''
6594         True if the datasource is reachable and the credentials are valid.
6595        '''
6596        self.hostname = hostname if hostname is not None else ''
6597        self.id = id if id is not None else ''
6598        '''
6599         Unique identifier of the Resource.
6600        '''
6601        self.name = name if name is not None else ''
6602        '''
6603         Unique human-readable name of the Resource.
6604        '''
6605        self.port = port if port is not None else 0
6606        self.port_override = port_override if port_override is not None else 0
6607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6608        '''
6609         ID of the secret store containing credentials for this resource, if any.
6610        '''
6611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6612        '''
6613         Tags is a map of key, value pairs.
6614        '''
6615        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6633    def to_dict(self):
6634        return {
6635            'bind_interface': self.bind_interface,
6636            'egress_filter': self.egress_filter,
6637            'healthcheck_namespace': self.healthcheck_namespace,
6638            'healthy': self.healthy,
6639            'hostname': self.hostname,
6640            'id': self.id,
6641            'name': self.name,
6642            'port': self.port,
6643            'port_override': self.port_override,
6644            'secret_store_id': self.secret_store_id,
6645            'tags': self.tags,
6646            'token': self.token,
6647        }
@classmethod
def from_dict(cls, d)
6649    @classmethod
6650    def from_dict(cls, d):
6651        return cls(
6652            bind_interface=d.get('bind_interface'),
6653            egress_filter=d.get('egress_filter'),
6654            healthcheck_namespace=d.get('healthcheck_namespace'),
6655            healthy=d.get('healthy'),
6656            hostname=d.get('hostname'),
6657            id=d.get('id'),
6658            name=d.get('name'),
6659            port=d.get('port'),
6660            port_override=d.get('port_override'),
6661            secret_store_id=d.get('secret_store_id'),
6662            tags=d.get('tags'),
6663            token=d.get('token'),
6664        )
class KubernetesUserImpersonation:
6667class KubernetesUserImpersonation:
6668    __slots__ = [
6669        'bind_interface',
6670        'certificate_authority',
6671        'client_certificate',
6672        'client_key',
6673        'egress_filter',
6674        'healthcheck_namespace',
6675        'healthy',
6676        'hostname',
6677        'id',
6678        'name',
6679        'port',
6680        'port_override',
6681        'secret_store_id',
6682        'tags',
6683    ]
6684
6685    def __init__(
6686        self,
6687        bind_interface=None,
6688        certificate_authority=None,
6689        client_certificate=None,
6690        client_key=None,
6691        egress_filter=None,
6692        healthcheck_namespace=None,
6693        healthy=None,
6694        hostname=None,
6695        id=None,
6696        name=None,
6697        port=None,
6698        port_override=None,
6699        secret_store_id=None,
6700        tags=None,
6701    ):
6702        self.bind_interface = bind_interface if bind_interface is not None else ''
6703        '''
6704         Bind interface
6705        '''
6706        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6707        self.client_certificate = client_certificate if client_certificate is not None else ''
6708        self.client_key = client_key if client_key is not None else ''
6709        self.egress_filter = egress_filter if egress_filter is not None else ''
6710        '''
6711         A filter applied to the routing logic to pin datasource to nodes.
6712        '''
6713        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6714        '''
6715         The path used to check the health of your connection.  Defaults to `default`.
6716        '''
6717        self.healthy = healthy if healthy is not None else False
6718        '''
6719         True if the datasource is reachable and the credentials are valid.
6720        '''
6721        self.hostname = hostname if hostname is not None else ''
6722        self.id = id if id is not None else ''
6723        '''
6724         Unique identifier of the Resource.
6725        '''
6726        self.name = name if name is not None else ''
6727        '''
6728         Unique human-readable name of the Resource.
6729        '''
6730        self.port = port if port is not None else 0
6731        self.port_override = port_override if port_override is not None else 0
6732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6733        '''
6734         ID of the secret store containing credentials for this resource, if any.
6735        '''
6736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6737        '''
6738         Tags is a map of key, value pairs.
6739        '''
6740
6741    def __repr__(self):
6742        return '<sdm.KubernetesUserImpersonation ' + \
6743            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6744            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6745            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6746            'client_key: ' + repr(self.client_key) + ' ' +\
6747            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6748            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6749            'healthy: ' + repr(self.healthy) + ' ' +\
6750            'hostname: ' + repr(self.hostname) + ' ' +\
6751            'id: ' + repr(self.id) + ' ' +\
6752            'name: ' + repr(self.name) + ' ' +\
6753            'port: ' + repr(self.port) + ' ' +\
6754            'port_override: ' + repr(self.port_override) + ' ' +\
6755            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6756            'tags: ' + repr(self.tags) + ' ' +\
6757            '>'
6758
6759    def to_dict(self):
6760        return {
6761            'bind_interface': self.bind_interface,
6762            'certificate_authority': self.certificate_authority,
6763            'client_certificate': self.client_certificate,
6764            'client_key': self.client_key,
6765            'egress_filter': self.egress_filter,
6766            'healthcheck_namespace': self.healthcheck_namespace,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
6776
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            certificate_authority=d.get('certificate_authority'),
6782            client_certificate=d.get('client_certificate'),
6783            client_key=d.get('client_key'),
6784            egress_filter=d.get('egress_filter'),
6785            healthcheck_namespace=d.get('healthcheck_namespace'),
6786            healthy=d.get('healthy'),
6787            hostname=d.get('hostname'),
6788            id=d.get('id'),
6789            name=d.get('name'),
6790            port=d.get('port'),
6791            port_override=d.get('port_override'),
6792            secret_store_id=d.get('secret_store_id'),
6793            tags=d.get('tags'),
6794        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6685    def __init__(
6686        self,
6687        bind_interface=None,
6688        certificate_authority=None,
6689        client_certificate=None,
6690        client_key=None,
6691        egress_filter=None,
6692        healthcheck_namespace=None,
6693        healthy=None,
6694        hostname=None,
6695        id=None,
6696        name=None,
6697        port=None,
6698        port_override=None,
6699        secret_store_id=None,
6700        tags=None,
6701    ):
6702        self.bind_interface = bind_interface if bind_interface is not None else ''
6703        '''
6704         Bind interface
6705        '''
6706        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6707        self.client_certificate = client_certificate if client_certificate is not None else ''
6708        self.client_key = client_key if client_key is not None else ''
6709        self.egress_filter = egress_filter if egress_filter is not None else ''
6710        '''
6711         A filter applied to the routing logic to pin datasource to nodes.
6712        '''
6713        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6714        '''
6715         The path used to check the health of your connection.  Defaults to `default`.
6716        '''
6717        self.healthy = healthy if healthy is not None else False
6718        '''
6719         True if the datasource is reachable and the credentials are valid.
6720        '''
6721        self.hostname = hostname if hostname is not None else ''
6722        self.id = id if id is not None else ''
6723        '''
6724         Unique identifier of the Resource.
6725        '''
6726        self.name = name if name is not None else ''
6727        '''
6728         Unique human-readable name of the Resource.
6729        '''
6730        self.port = port if port is not None else 0
6731        self.port_override = port_override if port_override is not None else 0
6732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6733        '''
6734         ID of the secret store containing credentials for this resource, if any.
6735        '''
6736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6737        '''
6738         Tags is a map of key, value pairs.
6739        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6759    def to_dict(self):
6760        return {
6761            'bind_interface': self.bind_interface,
6762            'certificate_authority': self.certificate_authority,
6763            'client_certificate': self.client_certificate,
6764            'client_key': self.client_key,
6765            'egress_filter': self.egress_filter,
6766            'healthcheck_namespace': self.healthcheck_namespace,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
@classmethod
def from_dict(cls, d)
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            certificate_authority=d.get('certificate_authority'),
6782            client_certificate=d.get('client_certificate'),
6783            client_key=d.get('client_key'),
6784            egress_filter=d.get('egress_filter'),
6785            healthcheck_namespace=d.get('healthcheck_namespace'),
6786            healthy=d.get('healthy'),
6787            hostname=d.get('hostname'),
6788            id=d.get('id'),
6789            name=d.get('name'),
6790            port=d.get('port'),
6791            port_override=d.get('port_override'),
6792            secret_store_id=d.get('secret_store_id'),
6793            tags=d.get('tags'),
6794        )
class MTLSMysql:
6797class MTLSMysql:
6798    '''
6799    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6800    without a major version bump.
6801    '''
6802    __slots__ = [
6803        'bind_interface',
6804        'certificate_authority',
6805        'client_certificate',
6806        'client_key',
6807        'database',
6808        'egress_filter',
6809        'healthy',
6810        'hostname',
6811        'id',
6812        'name',
6813        'password',
6814        'port',
6815        'port_override',
6816        'secret_store_id',
6817        'server_name',
6818        'tags',
6819        'username',
6820    ]
6821
6822    def __init__(
6823        self,
6824        bind_interface=None,
6825        certificate_authority=None,
6826        client_certificate=None,
6827        client_key=None,
6828        database=None,
6829        egress_filter=None,
6830        healthy=None,
6831        hostname=None,
6832        id=None,
6833        name=None,
6834        password=None,
6835        port=None,
6836        port_override=None,
6837        secret_store_id=None,
6838        server_name=None,
6839        tags=None,
6840        username=None,
6841    ):
6842        self.bind_interface = bind_interface if bind_interface is not None else ''
6843        '''
6844         Bind interface
6845        '''
6846        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6847        self.client_certificate = client_certificate if client_certificate is not None else ''
6848        self.client_key = client_key if client_key is not None else ''
6849        self.database = database if database is not None else ''
6850        self.egress_filter = egress_filter if egress_filter is not None else ''
6851        '''
6852         A filter applied to the routing logic to pin datasource to nodes.
6853        '''
6854        self.healthy = healthy if healthy is not None else False
6855        '''
6856         True if the datasource is reachable and the credentials are valid.
6857        '''
6858        self.hostname = hostname if hostname is not None else ''
6859        self.id = id if id is not None else ''
6860        '''
6861         Unique identifier of the Resource.
6862        '''
6863        self.name = name if name is not None else ''
6864        '''
6865         Unique human-readable name of the Resource.
6866        '''
6867        self.password = password if password is not None else ''
6868        self.port = port if port is not None else 0
6869        self.port_override = port_override if port_override is not None else 0
6870        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6871        '''
6872         ID of the secret store containing credentials for this resource, if any.
6873        '''
6874        self.server_name = server_name if server_name is not None else ''
6875        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6876        '''
6877         Tags is a map of key, value pairs.
6878        '''
6879        self.username = username if username is not None else ''
6880
6881    def __repr__(self):
6882        return '<sdm.MTLSMysql ' + \
6883            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6884            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6885            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6886            'client_key: ' + repr(self.client_key) + ' ' +\
6887            'database: ' + repr(self.database) + ' ' +\
6888            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6889            'healthy: ' + repr(self.healthy) + ' ' +\
6890            'hostname: ' + repr(self.hostname) + ' ' +\
6891            'id: ' + repr(self.id) + ' ' +\
6892            'name: ' + repr(self.name) + ' ' +\
6893            'password: ' + repr(self.password) + ' ' +\
6894            'port: ' + repr(self.port) + ' ' +\
6895            'port_override: ' + repr(self.port_override) + ' ' +\
6896            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6897            'server_name: ' + repr(self.server_name) + ' ' +\
6898            'tags: ' + repr(self.tags) + ' ' +\
6899            'username: ' + repr(self.username) + ' ' +\
6900            '>'
6901
6902    def to_dict(self):
6903        return {
6904            'bind_interface': self.bind_interface,
6905            'certificate_authority': self.certificate_authority,
6906            'client_certificate': self.client_certificate,
6907            'client_key': self.client_key,
6908            'database': self.database,
6909            'egress_filter': self.egress_filter,
6910            'healthy': self.healthy,
6911            'hostname': self.hostname,
6912            'id': self.id,
6913            'name': self.name,
6914            'password': self.password,
6915            'port': self.port,
6916            'port_override': self.port_override,
6917            'secret_store_id': self.secret_store_id,
6918            'server_name': self.server_name,
6919            'tags': self.tags,
6920            'username': self.username,
6921        }
6922
6923    @classmethod
6924    def from_dict(cls, d):
6925        return cls(
6926            bind_interface=d.get('bind_interface'),
6927            certificate_authority=d.get('certificate_authority'),
6928            client_certificate=d.get('client_certificate'),
6929            client_key=d.get('client_key'),
6930            database=d.get('database'),
6931            egress_filter=d.get('egress_filter'),
6932            healthy=d.get('healthy'),
6933            hostname=d.get('hostname'),
6934            id=d.get('id'),
6935            name=d.get('name'),
6936            password=d.get('password'),
6937            port=d.get('port'),
6938            port_override=d.get('port_override'),
6939            secret_store_id=d.get('secret_store_id'),
6940            server_name=d.get('server_name'),
6941            tags=d.get('tags'),
6942            username=d.get('username'),
6943        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6822    def __init__(
6823        self,
6824        bind_interface=None,
6825        certificate_authority=None,
6826        client_certificate=None,
6827        client_key=None,
6828        database=None,
6829        egress_filter=None,
6830        healthy=None,
6831        hostname=None,
6832        id=None,
6833        name=None,
6834        password=None,
6835        port=None,
6836        port_override=None,
6837        secret_store_id=None,
6838        server_name=None,
6839        tags=None,
6840        username=None,
6841    ):
6842        self.bind_interface = bind_interface if bind_interface is not None else ''
6843        '''
6844         Bind interface
6845        '''
6846        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6847        self.client_certificate = client_certificate if client_certificate is not None else ''
6848        self.client_key = client_key if client_key is not None else ''
6849        self.database = database if database is not None else ''
6850        self.egress_filter = egress_filter if egress_filter is not None else ''
6851        '''
6852         A filter applied to the routing logic to pin datasource to nodes.
6853        '''
6854        self.healthy = healthy if healthy is not None else False
6855        '''
6856         True if the datasource is reachable and the credentials are valid.
6857        '''
6858        self.hostname = hostname if hostname is not None else ''
6859        self.id = id if id is not None else ''
6860        '''
6861         Unique identifier of the Resource.
6862        '''
6863        self.name = name if name is not None else ''
6864        '''
6865         Unique human-readable name of the Resource.
6866        '''
6867        self.password = password if password is not None else ''
6868        self.port = port if port is not None else 0
6869        self.port_override = port_override if port_override is not None else 0
6870        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6871        '''
6872         ID of the secret store containing credentials for this resource, if any.
6873        '''
6874        self.server_name = server_name if server_name is not None else ''
6875        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6876        '''
6877         Tags is a map of key, value pairs.
6878        '''
6879        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6902    def to_dict(self):
6903        return {
6904            'bind_interface': self.bind_interface,
6905            'certificate_authority': self.certificate_authority,
6906            'client_certificate': self.client_certificate,
6907            'client_key': self.client_key,
6908            'database': self.database,
6909            'egress_filter': self.egress_filter,
6910            'healthy': self.healthy,
6911            'hostname': self.hostname,
6912            'id': self.id,
6913            'name': self.name,
6914            'password': self.password,
6915            'port': self.port,
6916            'port_override': self.port_override,
6917            'secret_store_id': self.secret_store_id,
6918            'server_name': self.server_name,
6919            'tags': self.tags,
6920            'username': self.username,
6921        }
@classmethod
def from_dict(cls, d)
6923    @classmethod
6924    def from_dict(cls, d):
6925        return cls(
6926            bind_interface=d.get('bind_interface'),
6927            certificate_authority=d.get('certificate_authority'),
6928            client_certificate=d.get('client_certificate'),
6929            client_key=d.get('client_key'),
6930            database=d.get('database'),
6931            egress_filter=d.get('egress_filter'),
6932            healthy=d.get('healthy'),
6933            hostname=d.get('hostname'),
6934            id=d.get('id'),
6935            name=d.get('name'),
6936            password=d.get('password'),
6937            port=d.get('port'),
6938            port_override=d.get('port_override'),
6939            secret_store_id=d.get('secret_store_id'),
6940            server_name=d.get('server_name'),
6941            tags=d.get('tags'),
6942            username=d.get('username'),
6943        )
class MTLSPostgres:
6946class MTLSPostgres:
6947    __slots__ = [
6948        'bind_interface',
6949        'certificate_authority',
6950        'client_certificate',
6951        'client_key',
6952        'database',
6953        'egress_filter',
6954        'healthy',
6955        'hostname',
6956        'id',
6957        'name',
6958        'override_database',
6959        'password',
6960        'port',
6961        'port_override',
6962        'secret_store_id',
6963        'server_name',
6964        'tags',
6965        'username',
6966    ]
6967
6968    def __init__(
6969        self,
6970        bind_interface=None,
6971        certificate_authority=None,
6972        client_certificate=None,
6973        client_key=None,
6974        database=None,
6975        egress_filter=None,
6976        healthy=None,
6977        hostname=None,
6978        id=None,
6979        name=None,
6980        override_database=None,
6981        password=None,
6982        port=None,
6983        port_override=None,
6984        secret_store_id=None,
6985        server_name=None,
6986        tags=None,
6987        username=None,
6988    ):
6989        self.bind_interface = bind_interface if bind_interface is not None else ''
6990        '''
6991         Bind interface
6992        '''
6993        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6994        self.client_certificate = client_certificate if client_certificate is not None else ''
6995        self.client_key = client_key if client_key is not None else ''
6996        self.database = database if database is not None else ''
6997        self.egress_filter = egress_filter if egress_filter is not None else ''
6998        '''
6999         A filter applied to the routing logic to pin datasource to nodes.
7000        '''
7001        self.healthy = healthy if healthy is not None else False
7002        '''
7003         True if the datasource is reachable and the credentials are valid.
7004        '''
7005        self.hostname = hostname if hostname is not None else ''
7006        self.id = id if id is not None else ''
7007        '''
7008         Unique identifier of the Resource.
7009        '''
7010        self.name = name if name is not None else ''
7011        '''
7012         Unique human-readable name of the Resource.
7013        '''
7014        self.override_database = override_database if override_database is not None else False
7015        self.password = password if password is not None else ''
7016        self.port = port if port is not None else 0
7017        self.port_override = port_override if port_override is not None else 0
7018        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7019        '''
7020         ID of the secret store containing credentials for this resource, if any.
7021        '''
7022        self.server_name = server_name if server_name is not None else ''
7023        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7024        '''
7025         Tags is a map of key, value pairs.
7026        '''
7027        self.username = username if username is not None else ''
7028
7029    def __repr__(self):
7030        return '<sdm.MTLSPostgres ' + \
7031            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7032            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7033            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7034            'client_key: ' + repr(self.client_key) + ' ' +\
7035            'database: ' + repr(self.database) + ' ' +\
7036            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7037            'healthy: ' + repr(self.healthy) + ' ' +\
7038            'hostname: ' + repr(self.hostname) + ' ' +\
7039            'id: ' + repr(self.id) + ' ' +\
7040            'name: ' + repr(self.name) + ' ' +\
7041            'override_database: ' + repr(self.override_database) + ' ' +\
7042            'password: ' + repr(self.password) + ' ' +\
7043            'port: ' + repr(self.port) + ' ' +\
7044            'port_override: ' + repr(self.port_override) + ' ' +\
7045            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7046            'server_name: ' + repr(self.server_name) + ' ' +\
7047            'tags: ' + repr(self.tags) + ' ' +\
7048            'username: ' + repr(self.username) + ' ' +\
7049            '>'
7050
7051    def to_dict(self):
7052        return {
7053            'bind_interface': self.bind_interface,
7054            'certificate_authority': self.certificate_authority,
7055            'client_certificate': self.client_certificate,
7056            'client_key': self.client_key,
7057            'database': self.database,
7058            'egress_filter': self.egress_filter,
7059            'healthy': self.healthy,
7060            'hostname': self.hostname,
7061            'id': self.id,
7062            'name': self.name,
7063            'override_database': self.override_database,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
7072
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            override_database=d.get('override_database'),
7087            password=d.get('password'),
7088            port=d.get('port'),
7089            port_override=d.get('port_override'),
7090            secret_store_id=d.get('secret_store_id'),
7091            server_name=d.get('server_name'),
7092            tags=d.get('tags'),
7093            username=d.get('username'),
7094        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6968    def __init__(
6969        self,
6970        bind_interface=None,
6971        certificate_authority=None,
6972        client_certificate=None,
6973        client_key=None,
6974        database=None,
6975        egress_filter=None,
6976        healthy=None,
6977        hostname=None,
6978        id=None,
6979        name=None,
6980        override_database=None,
6981        password=None,
6982        port=None,
6983        port_override=None,
6984        secret_store_id=None,
6985        server_name=None,
6986        tags=None,
6987        username=None,
6988    ):
6989        self.bind_interface = bind_interface if bind_interface is not None else ''
6990        '''
6991         Bind interface
6992        '''
6993        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6994        self.client_certificate = client_certificate if client_certificate is not None else ''
6995        self.client_key = client_key if client_key is not None else ''
6996        self.database = database if database is not None else ''
6997        self.egress_filter = egress_filter if egress_filter is not None else ''
6998        '''
6999         A filter applied to the routing logic to pin datasource to nodes.
7000        '''
7001        self.healthy = healthy if healthy is not None else False
7002        '''
7003         True if the datasource is reachable and the credentials are valid.
7004        '''
7005        self.hostname = hostname if hostname is not None else ''
7006        self.id = id if id is not None else ''
7007        '''
7008         Unique identifier of the Resource.
7009        '''
7010        self.name = name if name is not None else ''
7011        '''
7012         Unique human-readable name of the Resource.
7013        '''
7014        self.override_database = override_database if override_database is not None else False
7015        self.password = password if password is not None else ''
7016        self.port = port if port is not None else 0
7017        self.port_override = port_override if port_override is not None else 0
7018        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7019        '''
7020         ID of the secret store containing credentials for this resource, if any.
7021        '''
7022        self.server_name = server_name if server_name is not None else ''
7023        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7024        '''
7025         Tags is a map of key, value pairs.
7026        '''
7027        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7051    def to_dict(self):
7052        return {
7053            'bind_interface': self.bind_interface,
7054            'certificate_authority': self.certificate_authority,
7055            'client_certificate': self.client_certificate,
7056            'client_key': self.client_key,
7057            'database': self.database,
7058            'egress_filter': self.egress_filter,
7059            'healthy': self.healthy,
7060            'hostname': self.hostname,
7061            'id': self.id,
7062            'name': self.name,
7063            'override_database': self.override_database,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
@classmethod
def from_dict(cls, d)
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            override_database=d.get('override_database'),
7087            password=d.get('password'),
7088            port=d.get('port'),
7089            port_override=d.get('port_override'),
7090            secret_store_id=d.get('secret_store_id'),
7091            server_name=d.get('server_name'),
7092            tags=d.get('tags'),
7093            username=d.get('username'),
7094        )
class Maria:
7097class Maria:
7098    __slots__ = [
7099        'bind_interface',
7100        'database',
7101        'egress_filter',
7102        'healthy',
7103        'hostname',
7104        'id',
7105        'name',
7106        'password',
7107        'port',
7108        'port_override',
7109        'secret_store_id',
7110        'tags',
7111        'username',
7112    ]
7113
7114    def __init__(
7115        self,
7116        bind_interface=None,
7117        database=None,
7118        egress_filter=None,
7119        healthy=None,
7120        hostname=None,
7121        id=None,
7122        name=None,
7123        password=None,
7124        port=None,
7125        port_override=None,
7126        secret_store_id=None,
7127        tags=None,
7128        username=None,
7129    ):
7130        self.bind_interface = bind_interface if bind_interface is not None else ''
7131        '''
7132         Bind interface
7133        '''
7134        self.database = database if database is not None else ''
7135        self.egress_filter = egress_filter if egress_filter is not None else ''
7136        '''
7137         A filter applied to the routing logic to pin datasource to nodes.
7138        '''
7139        self.healthy = healthy if healthy is not None else False
7140        '''
7141         True if the datasource is reachable and the credentials are valid.
7142        '''
7143        self.hostname = hostname if hostname is not None else ''
7144        self.id = id if id is not None else ''
7145        '''
7146         Unique identifier of the Resource.
7147        '''
7148        self.name = name if name is not None else ''
7149        '''
7150         Unique human-readable name of the Resource.
7151        '''
7152        self.password = password if password is not None else ''
7153        self.port = port if port is not None else 0
7154        self.port_override = port_override if port_override is not None else 0
7155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7156        '''
7157         ID of the secret store containing credentials for this resource, if any.
7158        '''
7159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7160        '''
7161         Tags is a map of key, value pairs.
7162        '''
7163        self.username = username if username is not None else ''
7164
7165    def __repr__(self):
7166        return '<sdm.Maria ' + \
7167            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7168            'database: ' + repr(self.database) + ' ' +\
7169            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7170            'healthy: ' + repr(self.healthy) + ' ' +\
7171            'hostname: ' + repr(self.hostname) + ' ' +\
7172            'id: ' + repr(self.id) + ' ' +\
7173            'name: ' + repr(self.name) + ' ' +\
7174            'password: ' + repr(self.password) + ' ' +\
7175            'port: ' + repr(self.port) + ' ' +\
7176            'port_override: ' + repr(self.port_override) + ' ' +\
7177            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7178            'tags: ' + repr(self.tags) + ' ' +\
7179            'username: ' + repr(self.username) + ' ' +\
7180            '>'
7181
7182    def to_dict(self):
7183        return {
7184            'bind_interface': self.bind_interface,
7185            'database': self.database,
7186            'egress_filter': self.egress_filter,
7187            'healthy': self.healthy,
7188            'hostname': self.hostname,
7189            'id': self.id,
7190            'name': self.name,
7191            'password': self.password,
7192            'port': self.port,
7193            'port_override': self.port_override,
7194            'secret_store_id': self.secret_store_id,
7195            'tags': self.tags,
7196            'username': self.username,
7197        }
7198
7199    @classmethod
7200    def from_dict(cls, d):
7201        return cls(
7202            bind_interface=d.get('bind_interface'),
7203            database=d.get('database'),
7204            egress_filter=d.get('egress_filter'),
7205            healthy=d.get('healthy'),
7206            hostname=d.get('hostname'),
7207            id=d.get('id'),
7208            name=d.get('name'),
7209            password=d.get('password'),
7210            port=d.get('port'),
7211            port_override=d.get('port_override'),
7212            secret_store_id=d.get('secret_store_id'),
7213            tags=d.get('tags'),
7214            username=d.get('username'),
7215        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7114    def __init__(
7115        self,
7116        bind_interface=None,
7117        database=None,
7118        egress_filter=None,
7119        healthy=None,
7120        hostname=None,
7121        id=None,
7122        name=None,
7123        password=None,
7124        port=None,
7125        port_override=None,
7126        secret_store_id=None,
7127        tags=None,
7128        username=None,
7129    ):
7130        self.bind_interface = bind_interface if bind_interface is not None else ''
7131        '''
7132         Bind interface
7133        '''
7134        self.database = database if database is not None else ''
7135        self.egress_filter = egress_filter if egress_filter is not None else ''
7136        '''
7137         A filter applied to the routing logic to pin datasource to nodes.
7138        '''
7139        self.healthy = healthy if healthy is not None else False
7140        '''
7141         True if the datasource is reachable and the credentials are valid.
7142        '''
7143        self.hostname = hostname if hostname is not None else ''
7144        self.id = id if id is not None else ''
7145        '''
7146         Unique identifier of the Resource.
7147        '''
7148        self.name = name if name is not None else ''
7149        '''
7150         Unique human-readable name of the Resource.
7151        '''
7152        self.password = password if password is not None else ''
7153        self.port = port if port is not None else 0
7154        self.port_override = port_override if port_override is not None else 0
7155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7156        '''
7157         ID of the secret store containing credentials for this resource, if any.
7158        '''
7159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7160        '''
7161         Tags is a map of key, value pairs.
7162        '''
7163        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7182    def to_dict(self):
7183        return {
7184            'bind_interface': self.bind_interface,
7185            'database': self.database,
7186            'egress_filter': self.egress_filter,
7187            'healthy': self.healthy,
7188            'hostname': self.hostname,
7189            'id': self.id,
7190            'name': self.name,
7191            'password': self.password,
7192            'port': self.port,
7193            'port_override': self.port_override,
7194            'secret_store_id': self.secret_store_id,
7195            'tags': self.tags,
7196            'username': self.username,
7197        }
@classmethod
def from_dict(cls, d)
7199    @classmethod
7200    def from_dict(cls, d):
7201        return cls(
7202            bind_interface=d.get('bind_interface'),
7203            database=d.get('database'),
7204            egress_filter=d.get('egress_filter'),
7205            healthy=d.get('healthy'),
7206            hostname=d.get('hostname'),
7207            id=d.get('id'),
7208            name=d.get('name'),
7209            password=d.get('password'),
7210            port=d.get('port'),
7211            port_override=d.get('port_override'),
7212            secret_store_id=d.get('secret_store_id'),
7213            tags=d.get('tags'),
7214            username=d.get('username'),
7215        )
class Memcached:
7218class Memcached:
7219    __slots__ = [
7220        'bind_interface',
7221        'egress_filter',
7222        'healthy',
7223        'hostname',
7224        'id',
7225        'name',
7226        'port',
7227        'port_override',
7228        'secret_store_id',
7229        'tags',
7230    ]
7231
7232    def __init__(
7233        self,
7234        bind_interface=None,
7235        egress_filter=None,
7236        healthy=None,
7237        hostname=None,
7238        id=None,
7239        name=None,
7240        port=None,
7241        port_override=None,
7242        secret_store_id=None,
7243        tags=None,
7244    ):
7245        self.bind_interface = bind_interface if bind_interface is not None else ''
7246        '''
7247         Bind interface
7248        '''
7249        self.egress_filter = egress_filter if egress_filter is not None else ''
7250        '''
7251         A filter applied to the routing logic to pin datasource to nodes.
7252        '''
7253        self.healthy = healthy if healthy is not None else False
7254        '''
7255         True if the datasource is reachable and the credentials are valid.
7256        '''
7257        self.hostname = hostname if hostname is not None else ''
7258        self.id = id if id is not None else ''
7259        '''
7260         Unique identifier of the Resource.
7261        '''
7262        self.name = name if name is not None else ''
7263        '''
7264         Unique human-readable name of the Resource.
7265        '''
7266        self.port = port if port is not None else 0
7267        self.port_override = port_override if port_override is not None else 0
7268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7269        '''
7270         ID of the secret store containing credentials for this resource, if any.
7271        '''
7272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7273        '''
7274         Tags is a map of key, value pairs.
7275        '''
7276
7277    def __repr__(self):
7278        return '<sdm.Memcached ' + \
7279            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7280            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7281            'healthy: ' + repr(self.healthy) + ' ' +\
7282            'hostname: ' + repr(self.hostname) + ' ' +\
7283            'id: ' + repr(self.id) + ' ' +\
7284            'name: ' + repr(self.name) + ' ' +\
7285            'port: ' + repr(self.port) + ' ' +\
7286            'port_override: ' + repr(self.port_override) + ' ' +\
7287            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7288            'tags: ' + repr(self.tags) + ' ' +\
7289            '>'
7290
7291    def to_dict(self):
7292        return {
7293            'bind_interface': self.bind_interface,
7294            'egress_filter': self.egress_filter,
7295            'healthy': self.healthy,
7296            'hostname': self.hostname,
7297            'id': self.id,
7298            'name': self.name,
7299            'port': self.port,
7300            'port_override': self.port_override,
7301            'secret_store_id': self.secret_store_id,
7302            'tags': self.tags,
7303        }
7304
7305    @classmethod
7306    def from_dict(cls, d):
7307        return cls(
7308            bind_interface=d.get('bind_interface'),
7309            egress_filter=d.get('egress_filter'),
7310            healthy=d.get('healthy'),
7311            hostname=d.get('hostname'),
7312            id=d.get('id'),
7313            name=d.get('name'),
7314            port=d.get('port'),
7315            port_override=d.get('port_override'),
7316            secret_store_id=d.get('secret_store_id'),
7317            tags=d.get('tags'),
7318        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7232    def __init__(
7233        self,
7234        bind_interface=None,
7235        egress_filter=None,
7236        healthy=None,
7237        hostname=None,
7238        id=None,
7239        name=None,
7240        port=None,
7241        port_override=None,
7242        secret_store_id=None,
7243        tags=None,
7244    ):
7245        self.bind_interface = bind_interface if bind_interface is not None else ''
7246        '''
7247         Bind interface
7248        '''
7249        self.egress_filter = egress_filter if egress_filter is not None else ''
7250        '''
7251         A filter applied to the routing logic to pin datasource to nodes.
7252        '''
7253        self.healthy = healthy if healthy is not None else False
7254        '''
7255         True if the datasource is reachable and the credentials are valid.
7256        '''
7257        self.hostname = hostname if hostname is not None else ''
7258        self.id = id if id is not None else ''
7259        '''
7260         Unique identifier of the Resource.
7261        '''
7262        self.name = name if name is not None else ''
7263        '''
7264         Unique human-readable name of the Resource.
7265        '''
7266        self.port = port if port is not None else 0
7267        self.port_override = port_override if port_override is not None else 0
7268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7269        '''
7270         ID of the secret store containing credentials for this resource, if any.
7271        '''
7272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7273        '''
7274         Tags is a map of key, value pairs.
7275        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7291    def to_dict(self):
7292        return {
7293            'bind_interface': self.bind_interface,
7294            'egress_filter': self.egress_filter,
7295            'healthy': self.healthy,
7296            'hostname': self.hostname,
7297            'id': self.id,
7298            'name': self.name,
7299            'port': self.port,
7300            'port_override': self.port_override,
7301            'secret_store_id': self.secret_store_id,
7302            'tags': self.tags,
7303        }
@classmethod
def from_dict(cls, d)
7305    @classmethod
7306    def from_dict(cls, d):
7307        return cls(
7308            bind_interface=d.get('bind_interface'),
7309            egress_filter=d.get('egress_filter'),
7310            healthy=d.get('healthy'),
7311            hostname=d.get('hostname'),
7312            id=d.get('id'),
7313            name=d.get('name'),
7314            port=d.get('port'),
7315            port_override=d.get('port_override'),
7316            secret_store_id=d.get('secret_store_id'),
7317            tags=d.get('tags'),
7318        )
class Memsql:
7321class Memsql:
7322    __slots__ = [
7323        'bind_interface',
7324        'database',
7325        'egress_filter',
7326        'healthy',
7327        'hostname',
7328        'id',
7329        'name',
7330        'password',
7331        'port',
7332        'port_override',
7333        'secret_store_id',
7334        'tags',
7335        'username',
7336    ]
7337
7338    def __init__(
7339        self,
7340        bind_interface=None,
7341        database=None,
7342        egress_filter=None,
7343        healthy=None,
7344        hostname=None,
7345        id=None,
7346        name=None,
7347        password=None,
7348        port=None,
7349        port_override=None,
7350        secret_store_id=None,
7351        tags=None,
7352        username=None,
7353    ):
7354        self.bind_interface = bind_interface if bind_interface is not None else ''
7355        '''
7356         Bind interface
7357        '''
7358        self.database = database if database is not None else ''
7359        self.egress_filter = egress_filter if egress_filter is not None else ''
7360        '''
7361         A filter applied to the routing logic to pin datasource to nodes.
7362        '''
7363        self.healthy = healthy if healthy is not None else False
7364        '''
7365         True if the datasource is reachable and the credentials are valid.
7366        '''
7367        self.hostname = hostname if hostname is not None else ''
7368        self.id = id if id is not None else ''
7369        '''
7370         Unique identifier of the Resource.
7371        '''
7372        self.name = name if name is not None else ''
7373        '''
7374         Unique human-readable name of the Resource.
7375        '''
7376        self.password = password if password is not None else ''
7377        self.port = port if port is not None else 0
7378        self.port_override = port_override if port_override is not None else 0
7379        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7380        '''
7381         ID of the secret store containing credentials for this resource, if any.
7382        '''
7383        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7384        '''
7385         Tags is a map of key, value pairs.
7386        '''
7387        self.username = username if username is not None else ''
7388
7389    def __repr__(self):
7390        return '<sdm.Memsql ' + \
7391            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7392            'database: ' + repr(self.database) + ' ' +\
7393            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7394            'healthy: ' + repr(self.healthy) + ' ' +\
7395            'hostname: ' + repr(self.hostname) + ' ' +\
7396            'id: ' + repr(self.id) + ' ' +\
7397            'name: ' + repr(self.name) + ' ' +\
7398            'password: ' + repr(self.password) + ' ' +\
7399            'port: ' + repr(self.port) + ' ' +\
7400            'port_override: ' + repr(self.port_override) + ' ' +\
7401            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7402            'tags: ' + repr(self.tags) + ' ' +\
7403            'username: ' + repr(self.username) + ' ' +\
7404            '>'
7405
7406    def to_dict(self):
7407        return {
7408            'bind_interface': self.bind_interface,
7409            'database': self.database,
7410            'egress_filter': self.egress_filter,
7411            'healthy': self.healthy,
7412            'hostname': self.hostname,
7413            'id': self.id,
7414            'name': self.name,
7415            'password': self.password,
7416            'port': self.port,
7417            'port_override': self.port_override,
7418            'secret_store_id': self.secret_store_id,
7419            'tags': self.tags,
7420            'username': self.username,
7421        }
7422
7423    @classmethod
7424    def from_dict(cls, d):
7425        return cls(
7426            bind_interface=d.get('bind_interface'),
7427            database=d.get('database'),
7428            egress_filter=d.get('egress_filter'),
7429            healthy=d.get('healthy'),
7430            hostname=d.get('hostname'),
7431            id=d.get('id'),
7432            name=d.get('name'),
7433            password=d.get('password'),
7434            port=d.get('port'),
7435            port_override=d.get('port_override'),
7436            secret_store_id=d.get('secret_store_id'),
7437            tags=d.get('tags'),
7438            username=d.get('username'),
7439        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7338    def __init__(
7339        self,
7340        bind_interface=None,
7341        database=None,
7342        egress_filter=None,
7343        healthy=None,
7344        hostname=None,
7345        id=None,
7346        name=None,
7347        password=None,
7348        port=None,
7349        port_override=None,
7350        secret_store_id=None,
7351        tags=None,
7352        username=None,
7353    ):
7354        self.bind_interface = bind_interface if bind_interface is not None else ''
7355        '''
7356         Bind interface
7357        '''
7358        self.database = database if database is not None else ''
7359        self.egress_filter = egress_filter if egress_filter is not None else ''
7360        '''
7361         A filter applied to the routing logic to pin datasource to nodes.
7362        '''
7363        self.healthy = healthy if healthy is not None else False
7364        '''
7365         True if the datasource is reachable and the credentials are valid.
7366        '''
7367        self.hostname = hostname if hostname is not None else ''
7368        self.id = id if id is not None else ''
7369        '''
7370         Unique identifier of the Resource.
7371        '''
7372        self.name = name if name is not None else ''
7373        '''
7374         Unique human-readable name of the Resource.
7375        '''
7376        self.password = password if password is not None else ''
7377        self.port = port if port is not None else 0
7378        self.port_override = port_override if port_override is not None else 0
7379        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7380        '''
7381         ID of the secret store containing credentials for this resource, if any.
7382        '''
7383        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7384        '''
7385         Tags is a map of key, value pairs.
7386        '''
7387        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7406    def to_dict(self):
7407        return {
7408            'bind_interface': self.bind_interface,
7409            'database': self.database,
7410            'egress_filter': self.egress_filter,
7411            'healthy': self.healthy,
7412            'hostname': self.hostname,
7413            'id': self.id,
7414            'name': self.name,
7415            'password': self.password,
7416            'port': self.port,
7417            'port_override': self.port_override,
7418            'secret_store_id': self.secret_store_id,
7419            'tags': self.tags,
7420            'username': self.username,
7421        }
@classmethod
def from_dict(cls, d)
7423    @classmethod
7424    def from_dict(cls, d):
7425        return cls(
7426            bind_interface=d.get('bind_interface'),
7427            database=d.get('database'),
7428            egress_filter=d.get('egress_filter'),
7429            healthy=d.get('healthy'),
7430            hostname=d.get('hostname'),
7431            id=d.get('id'),
7432            name=d.get('name'),
7433            password=d.get('password'),
7434            port=d.get('port'),
7435            port_override=d.get('port_override'),
7436            secret_store_id=d.get('secret_store_id'),
7437            tags=d.get('tags'),
7438            username=d.get('username'),
7439        )
class MongoHost:
7442class MongoHost:
7443    '''
7444    MongoHost is currently unstable, and its API may change, or it may be removed,
7445    without a major version bump.
7446    '''
7447    __slots__ = [
7448        'auth_database',
7449        'bind_interface',
7450        'egress_filter',
7451        'healthy',
7452        'hostname',
7453        'id',
7454        'name',
7455        'password',
7456        'port',
7457        'port_override',
7458        'secret_store_id',
7459        'tags',
7460        'tls_required',
7461        'username',
7462    ]
7463
7464    def __init__(
7465        self,
7466        auth_database=None,
7467        bind_interface=None,
7468        egress_filter=None,
7469        healthy=None,
7470        hostname=None,
7471        id=None,
7472        name=None,
7473        password=None,
7474        port=None,
7475        port_override=None,
7476        secret_store_id=None,
7477        tags=None,
7478        tls_required=None,
7479        username=None,
7480    ):
7481        self.auth_database = auth_database if auth_database is not None else ''
7482        self.bind_interface = bind_interface if bind_interface is not None else ''
7483        '''
7484         Bind interface
7485        '''
7486        self.egress_filter = egress_filter if egress_filter is not None else ''
7487        '''
7488         A filter applied to the routing logic to pin datasource to nodes.
7489        '''
7490        self.healthy = healthy if healthy is not None else False
7491        '''
7492         True if the datasource is reachable and the credentials are valid.
7493        '''
7494        self.hostname = hostname if hostname is not None else ''
7495        self.id = id if id is not None else ''
7496        '''
7497         Unique identifier of the Resource.
7498        '''
7499        self.name = name if name is not None else ''
7500        '''
7501         Unique human-readable name of the Resource.
7502        '''
7503        self.password = password if password is not None else ''
7504        self.port = port if port is not None else 0
7505        self.port_override = port_override if port_override is not None else 0
7506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7507        '''
7508         ID of the secret store containing credentials for this resource, if any.
7509        '''
7510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7511        '''
7512         Tags is a map of key, value pairs.
7513        '''
7514        self.tls_required = tls_required if tls_required is not None else False
7515        self.username = username if username is not None else ''
7516
7517    def __repr__(self):
7518        return '<sdm.MongoHost ' + \
7519            'auth_database: ' + repr(self.auth_database) + ' ' +\
7520            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7521            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7522            'healthy: ' + repr(self.healthy) + ' ' +\
7523            'hostname: ' + repr(self.hostname) + ' ' +\
7524            'id: ' + repr(self.id) + ' ' +\
7525            'name: ' + repr(self.name) + ' ' +\
7526            'password: ' + repr(self.password) + ' ' +\
7527            'port: ' + repr(self.port) + ' ' +\
7528            'port_override: ' + repr(self.port_override) + ' ' +\
7529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7530            'tags: ' + repr(self.tags) + ' ' +\
7531            'tls_required: ' + repr(self.tls_required) + ' ' +\
7532            'username: ' + repr(self.username) + ' ' +\
7533            '>'
7534
7535    def to_dict(self):
7536        return {
7537            'auth_database': self.auth_database,
7538            'bind_interface': self.bind_interface,
7539            'egress_filter': self.egress_filter,
7540            'healthy': self.healthy,
7541            'hostname': self.hostname,
7542            'id': self.id,
7543            'name': self.name,
7544            'password': self.password,
7545            'port': self.port,
7546            'port_override': self.port_override,
7547            'secret_store_id': self.secret_store_id,
7548            'tags': self.tags,
7549            'tls_required': self.tls_required,
7550            'username': self.username,
7551        }
7552
7553    @classmethod
7554    def from_dict(cls, d):
7555        return cls(
7556            auth_database=d.get('auth_database'),
7557            bind_interface=d.get('bind_interface'),
7558            egress_filter=d.get('egress_filter'),
7559            healthy=d.get('healthy'),
7560            hostname=d.get('hostname'),
7561            id=d.get('id'),
7562            name=d.get('name'),
7563            password=d.get('password'),
7564            port=d.get('port'),
7565            port_override=d.get('port_override'),
7566            secret_store_id=d.get('secret_store_id'),
7567            tags=d.get('tags'),
7568            tls_required=d.get('tls_required'),
7569            username=d.get('username'),
7570        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7464    def __init__(
7465        self,
7466        auth_database=None,
7467        bind_interface=None,
7468        egress_filter=None,
7469        healthy=None,
7470        hostname=None,
7471        id=None,
7472        name=None,
7473        password=None,
7474        port=None,
7475        port_override=None,
7476        secret_store_id=None,
7477        tags=None,
7478        tls_required=None,
7479        username=None,
7480    ):
7481        self.auth_database = auth_database if auth_database is not None else ''
7482        self.bind_interface = bind_interface if bind_interface is not None else ''
7483        '''
7484         Bind interface
7485        '''
7486        self.egress_filter = egress_filter if egress_filter is not None else ''
7487        '''
7488         A filter applied to the routing logic to pin datasource to nodes.
7489        '''
7490        self.healthy = healthy if healthy is not None else False
7491        '''
7492         True if the datasource is reachable and the credentials are valid.
7493        '''
7494        self.hostname = hostname if hostname is not None else ''
7495        self.id = id if id is not None else ''
7496        '''
7497         Unique identifier of the Resource.
7498        '''
7499        self.name = name if name is not None else ''
7500        '''
7501         Unique human-readable name of the Resource.
7502        '''
7503        self.password = password if password is not None else ''
7504        self.port = port if port is not None else 0
7505        self.port_override = port_override if port_override is not None else 0
7506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7507        '''
7508         ID of the secret store containing credentials for this resource, if any.
7509        '''
7510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7511        '''
7512         Tags is a map of key, value pairs.
7513        '''
7514        self.tls_required = tls_required if tls_required is not None else False
7515        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7535    def to_dict(self):
7536        return {
7537            'auth_database': self.auth_database,
7538            'bind_interface': self.bind_interface,
7539            'egress_filter': self.egress_filter,
7540            'healthy': self.healthy,
7541            'hostname': self.hostname,
7542            'id': self.id,
7543            'name': self.name,
7544            'password': self.password,
7545            'port': self.port,
7546            'port_override': self.port_override,
7547            'secret_store_id': self.secret_store_id,
7548            'tags': self.tags,
7549            'tls_required': self.tls_required,
7550            'username': self.username,
7551        }
@classmethod
def from_dict(cls, d)
7553    @classmethod
7554    def from_dict(cls, d):
7555        return cls(
7556            auth_database=d.get('auth_database'),
7557            bind_interface=d.get('bind_interface'),
7558            egress_filter=d.get('egress_filter'),
7559            healthy=d.get('healthy'),
7560            hostname=d.get('hostname'),
7561            id=d.get('id'),
7562            name=d.get('name'),
7563            password=d.get('password'),
7564            port=d.get('port'),
7565            port_override=d.get('port_override'),
7566            secret_store_id=d.get('secret_store_id'),
7567            tags=d.get('tags'),
7568            tls_required=d.get('tls_required'),
7569            username=d.get('username'),
7570        )
class MongoLegacyHost:
7573class MongoLegacyHost:
7574    __slots__ = [
7575        'auth_database',
7576        'bind_interface',
7577        'egress_filter',
7578        'healthy',
7579        'hostname',
7580        'id',
7581        'name',
7582        'password',
7583        'port',
7584        'port_override',
7585        'replica_set',
7586        'secret_store_id',
7587        'tags',
7588        'tls_required',
7589        'username',
7590    ]
7591
7592    def __init__(
7593        self,
7594        auth_database=None,
7595        bind_interface=None,
7596        egress_filter=None,
7597        healthy=None,
7598        hostname=None,
7599        id=None,
7600        name=None,
7601        password=None,
7602        port=None,
7603        port_override=None,
7604        replica_set=None,
7605        secret_store_id=None,
7606        tags=None,
7607        tls_required=None,
7608        username=None,
7609    ):
7610        self.auth_database = auth_database if auth_database is not None else ''
7611        self.bind_interface = bind_interface if bind_interface is not None else ''
7612        '''
7613         Bind interface
7614        '''
7615        self.egress_filter = egress_filter if egress_filter is not None else ''
7616        '''
7617         A filter applied to the routing logic to pin datasource to nodes.
7618        '''
7619        self.healthy = healthy if healthy is not None else False
7620        '''
7621         True if the datasource is reachable and the credentials are valid.
7622        '''
7623        self.hostname = hostname if hostname is not None else ''
7624        self.id = id if id is not None else ''
7625        '''
7626         Unique identifier of the Resource.
7627        '''
7628        self.name = name if name is not None else ''
7629        '''
7630         Unique human-readable name of the Resource.
7631        '''
7632        self.password = password if password is not None else ''
7633        self.port = port if port is not None else 0
7634        self.port_override = port_override if port_override is not None else 0
7635        self.replica_set = replica_set if replica_set is not None else ''
7636        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7637        '''
7638         ID of the secret store containing credentials for this resource, if any.
7639        '''
7640        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7641        '''
7642         Tags is a map of key, value pairs.
7643        '''
7644        self.tls_required = tls_required if tls_required is not None else False
7645        self.username = username if username is not None else ''
7646
7647    def __repr__(self):
7648        return '<sdm.MongoLegacyHost ' + \
7649            'auth_database: ' + repr(self.auth_database) + ' ' +\
7650            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7651            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7652            'healthy: ' + repr(self.healthy) + ' ' +\
7653            'hostname: ' + repr(self.hostname) + ' ' +\
7654            'id: ' + repr(self.id) + ' ' +\
7655            'name: ' + repr(self.name) + ' ' +\
7656            'password: ' + repr(self.password) + ' ' +\
7657            'port: ' + repr(self.port) + ' ' +\
7658            'port_override: ' + repr(self.port_override) + ' ' +\
7659            'replica_set: ' + repr(self.replica_set) + ' ' +\
7660            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7661            'tags: ' + repr(self.tags) + ' ' +\
7662            'tls_required: ' + repr(self.tls_required) + ' ' +\
7663            'username: ' + repr(self.username) + ' ' +\
7664            '>'
7665
7666    def to_dict(self):
7667        return {
7668            'auth_database': self.auth_database,
7669            'bind_interface': self.bind_interface,
7670            'egress_filter': self.egress_filter,
7671            'healthy': self.healthy,
7672            'hostname': self.hostname,
7673            'id': self.id,
7674            'name': self.name,
7675            'password': self.password,
7676            'port': self.port,
7677            'port_override': self.port_override,
7678            'replica_set': self.replica_set,
7679            'secret_store_id': self.secret_store_id,
7680            'tags': self.tags,
7681            'tls_required': self.tls_required,
7682            'username': self.username,
7683        }
7684
7685    @classmethod
7686    def from_dict(cls, d):
7687        return cls(
7688            auth_database=d.get('auth_database'),
7689            bind_interface=d.get('bind_interface'),
7690            egress_filter=d.get('egress_filter'),
7691            healthy=d.get('healthy'),
7692            hostname=d.get('hostname'),
7693            id=d.get('id'),
7694            name=d.get('name'),
7695            password=d.get('password'),
7696            port=d.get('port'),
7697            port_override=d.get('port_override'),
7698            replica_set=d.get('replica_set'),
7699            secret_store_id=d.get('secret_store_id'),
7700            tags=d.get('tags'),
7701            tls_required=d.get('tls_required'),
7702            username=d.get('username'),
7703        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7592    def __init__(
7593        self,
7594        auth_database=None,
7595        bind_interface=None,
7596        egress_filter=None,
7597        healthy=None,
7598        hostname=None,
7599        id=None,
7600        name=None,
7601        password=None,
7602        port=None,
7603        port_override=None,
7604        replica_set=None,
7605        secret_store_id=None,
7606        tags=None,
7607        tls_required=None,
7608        username=None,
7609    ):
7610        self.auth_database = auth_database if auth_database is not None else ''
7611        self.bind_interface = bind_interface if bind_interface is not None else ''
7612        '''
7613         Bind interface
7614        '''
7615        self.egress_filter = egress_filter if egress_filter is not None else ''
7616        '''
7617         A filter applied to the routing logic to pin datasource to nodes.
7618        '''
7619        self.healthy = healthy if healthy is not None else False
7620        '''
7621         True if the datasource is reachable and the credentials are valid.
7622        '''
7623        self.hostname = hostname if hostname is not None else ''
7624        self.id = id if id is not None else ''
7625        '''
7626         Unique identifier of the Resource.
7627        '''
7628        self.name = name if name is not None else ''
7629        '''
7630         Unique human-readable name of the Resource.
7631        '''
7632        self.password = password if password is not None else ''
7633        self.port = port if port is not None else 0
7634        self.port_override = port_override if port_override is not None else 0
7635        self.replica_set = replica_set if replica_set is not None else ''
7636        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7637        '''
7638         ID of the secret store containing credentials for this resource, if any.
7639        '''
7640        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7641        '''
7642         Tags is a map of key, value pairs.
7643        '''
7644        self.tls_required = tls_required if tls_required is not None else False
7645        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7666    def to_dict(self):
7667        return {
7668            'auth_database': self.auth_database,
7669            'bind_interface': self.bind_interface,
7670            'egress_filter': self.egress_filter,
7671            'healthy': self.healthy,
7672            'hostname': self.hostname,
7673            'id': self.id,
7674            'name': self.name,
7675            'password': self.password,
7676            'port': self.port,
7677            'port_override': self.port_override,
7678            'replica_set': self.replica_set,
7679            'secret_store_id': self.secret_store_id,
7680            'tags': self.tags,
7681            'tls_required': self.tls_required,
7682            'username': self.username,
7683        }
@classmethod
def from_dict(cls, d)
7685    @classmethod
7686    def from_dict(cls, d):
7687        return cls(
7688            auth_database=d.get('auth_database'),
7689            bind_interface=d.get('bind_interface'),
7690            egress_filter=d.get('egress_filter'),
7691            healthy=d.get('healthy'),
7692            hostname=d.get('hostname'),
7693            id=d.get('id'),
7694            name=d.get('name'),
7695            password=d.get('password'),
7696            port=d.get('port'),
7697            port_override=d.get('port_override'),
7698            replica_set=d.get('replica_set'),
7699            secret_store_id=d.get('secret_store_id'),
7700            tags=d.get('tags'),
7701            tls_required=d.get('tls_required'),
7702            username=d.get('username'),
7703        )
class MongoLegacyReplicaset:
7706class MongoLegacyReplicaset:
7707    __slots__ = [
7708        'auth_database',
7709        'bind_interface',
7710        'connect_to_replica',
7711        'egress_filter',
7712        'healthy',
7713        'hostname',
7714        'id',
7715        'name',
7716        'password',
7717        'port',
7718        'port_override',
7719        'replica_set',
7720        'secret_store_id',
7721        'tags',
7722        'tls_required',
7723        'username',
7724    ]
7725
7726    def __init__(
7727        self,
7728        auth_database=None,
7729        bind_interface=None,
7730        connect_to_replica=None,
7731        egress_filter=None,
7732        healthy=None,
7733        hostname=None,
7734        id=None,
7735        name=None,
7736        password=None,
7737        port=None,
7738        port_override=None,
7739        replica_set=None,
7740        secret_store_id=None,
7741        tags=None,
7742        tls_required=None,
7743        username=None,
7744    ):
7745        self.auth_database = auth_database if auth_database is not None else ''
7746        self.bind_interface = bind_interface if bind_interface is not None else ''
7747        '''
7748         Bind interface
7749        '''
7750        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7751        self.egress_filter = egress_filter if egress_filter is not None else ''
7752        '''
7753         A filter applied to the routing logic to pin datasource to nodes.
7754        '''
7755        self.healthy = healthy if healthy is not None else False
7756        '''
7757         True if the datasource is reachable and the credentials are valid.
7758        '''
7759        self.hostname = hostname if hostname is not None else ''
7760        self.id = id if id is not None else ''
7761        '''
7762         Unique identifier of the Resource.
7763        '''
7764        self.name = name if name is not None else ''
7765        '''
7766         Unique human-readable name of the Resource.
7767        '''
7768        self.password = password if password is not None else ''
7769        self.port = port if port is not None else 0
7770        self.port_override = port_override if port_override is not None else 0
7771        self.replica_set = replica_set if replica_set is not None else ''
7772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7773        '''
7774         ID of the secret store containing credentials for this resource, if any.
7775        '''
7776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7777        '''
7778         Tags is a map of key, value pairs.
7779        '''
7780        self.tls_required = tls_required if tls_required is not None else False
7781        self.username = username if username is not None else ''
7782
7783    def __repr__(self):
7784        return '<sdm.MongoLegacyReplicaset ' + \
7785            'auth_database: ' + repr(self.auth_database) + ' ' +\
7786            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7787            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7788            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7789            'healthy: ' + repr(self.healthy) + ' ' +\
7790            'hostname: ' + repr(self.hostname) + ' ' +\
7791            'id: ' + repr(self.id) + ' ' +\
7792            'name: ' + repr(self.name) + ' ' +\
7793            'password: ' + repr(self.password) + ' ' +\
7794            'port: ' + repr(self.port) + ' ' +\
7795            'port_override: ' + repr(self.port_override) + ' ' +\
7796            'replica_set: ' + repr(self.replica_set) + ' ' +\
7797            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7798            'tags: ' + repr(self.tags) + ' ' +\
7799            'tls_required: ' + repr(self.tls_required) + ' ' +\
7800            'username: ' + repr(self.username) + ' ' +\
7801            '>'
7802
7803    def to_dict(self):
7804        return {
7805            'auth_database': self.auth_database,
7806            'bind_interface': self.bind_interface,
7807            'connect_to_replica': self.connect_to_replica,
7808            'egress_filter': self.egress_filter,
7809            'healthy': self.healthy,
7810            'hostname': self.hostname,
7811            'id': self.id,
7812            'name': self.name,
7813            'password': self.password,
7814            'port': self.port,
7815            'port_override': self.port_override,
7816            'replica_set': self.replica_set,
7817            'secret_store_id': self.secret_store_id,
7818            'tags': self.tags,
7819            'tls_required': self.tls_required,
7820            'username': self.username,
7821        }
7822
7823    @classmethod
7824    def from_dict(cls, d):
7825        return cls(
7826            auth_database=d.get('auth_database'),
7827            bind_interface=d.get('bind_interface'),
7828            connect_to_replica=d.get('connect_to_replica'),
7829            egress_filter=d.get('egress_filter'),
7830            healthy=d.get('healthy'),
7831            hostname=d.get('hostname'),
7832            id=d.get('id'),
7833            name=d.get('name'),
7834            password=d.get('password'),
7835            port=d.get('port'),
7836            port_override=d.get('port_override'),
7837            replica_set=d.get('replica_set'),
7838            secret_store_id=d.get('secret_store_id'),
7839            tags=d.get('tags'),
7840            tls_required=d.get('tls_required'),
7841            username=d.get('username'),
7842        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7726    def __init__(
7727        self,
7728        auth_database=None,
7729        bind_interface=None,
7730        connect_to_replica=None,
7731        egress_filter=None,
7732        healthy=None,
7733        hostname=None,
7734        id=None,
7735        name=None,
7736        password=None,
7737        port=None,
7738        port_override=None,
7739        replica_set=None,
7740        secret_store_id=None,
7741        tags=None,
7742        tls_required=None,
7743        username=None,
7744    ):
7745        self.auth_database = auth_database if auth_database is not None else ''
7746        self.bind_interface = bind_interface if bind_interface is not None else ''
7747        '''
7748         Bind interface
7749        '''
7750        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7751        self.egress_filter = egress_filter if egress_filter is not None else ''
7752        '''
7753         A filter applied to the routing logic to pin datasource to nodes.
7754        '''
7755        self.healthy = healthy if healthy is not None else False
7756        '''
7757         True if the datasource is reachable and the credentials are valid.
7758        '''
7759        self.hostname = hostname if hostname is not None else ''
7760        self.id = id if id is not None else ''
7761        '''
7762         Unique identifier of the Resource.
7763        '''
7764        self.name = name if name is not None else ''
7765        '''
7766         Unique human-readable name of the Resource.
7767        '''
7768        self.password = password if password is not None else ''
7769        self.port = port if port is not None else 0
7770        self.port_override = port_override if port_override is not None else 0
7771        self.replica_set = replica_set if replica_set is not None else ''
7772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7773        '''
7774         ID of the secret store containing credentials for this resource, if any.
7775        '''
7776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7777        '''
7778         Tags is a map of key, value pairs.
7779        '''
7780        self.tls_required = tls_required if tls_required is not None else False
7781        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7803    def to_dict(self):
7804        return {
7805            'auth_database': self.auth_database,
7806            'bind_interface': self.bind_interface,
7807            'connect_to_replica': self.connect_to_replica,
7808            'egress_filter': self.egress_filter,
7809            'healthy': self.healthy,
7810            'hostname': self.hostname,
7811            'id': self.id,
7812            'name': self.name,
7813            'password': self.password,
7814            'port': self.port,
7815            'port_override': self.port_override,
7816            'replica_set': self.replica_set,
7817            'secret_store_id': self.secret_store_id,
7818            'tags': self.tags,
7819            'tls_required': self.tls_required,
7820            'username': self.username,
7821        }
@classmethod
def from_dict(cls, d)
7823    @classmethod
7824    def from_dict(cls, d):
7825        return cls(
7826            auth_database=d.get('auth_database'),
7827            bind_interface=d.get('bind_interface'),
7828            connect_to_replica=d.get('connect_to_replica'),
7829            egress_filter=d.get('egress_filter'),
7830            healthy=d.get('healthy'),
7831            hostname=d.get('hostname'),
7832            id=d.get('id'),
7833            name=d.get('name'),
7834            password=d.get('password'),
7835            port=d.get('port'),
7836            port_override=d.get('port_override'),
7837            replica_set=d.get('replica_set'),
7838            secret_store_id=d.get('secret_store_id'),
7839            tags=d.get('tags'),
7840            tls_required=d.get('tls_required'),
7841            username=d.get('username'),
7842        )
class MongoReplicaSet:
7845class MongoReplicaSet:
7846    '''
7847    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7848    without a major version bump.
7849    '''
7850    __slots__ = [
7851        'auth_database',
7852        'bind_interface',
7853        'connect_to_replica',
7854        'egress_filter',
7855        'healthy',
7856        'hostname',
7857        'id',
7858        'name',
7859        'password',
7860        'port',
7861        'port_override',
7862        'replica_set',
7863        'secret_store_id',
7864        'tags',
7865        'tls_required',
7866        'username',
7867    ]
7868
7869    def __init__(
7870        self,
7871        auth_database=None,
7872        bind_interface=None,
7873        connect_to_replica=None,
7874        egress_filter=None,
7875        healthy=None,
7876        hostname=None,
7877        id=None,
7878        name=None,
7879        password=None,
7880        port=None,
7881        port_override=None,
7882        replica_set=None,
7883        secret_store_id=None,
7884        tags=None,
7885        tls_required=None,
7886        username=None,
7887    ):
7888        self.auth_database = auth_database if auth_database is not None else ''
7889        self.bind_interface = bind_interface if bind_interface is not None else ''
7890        '''
7891         Bind interface
7892        '''
7893        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7894        self.egress_filter = egress_filter if egress_filter is not None else ''
7895        '''
7896         A filter applied to the routing logic to pin datasource to nodes.
7897        '''
7898        self.healthy = healthy if healthy is not None else False
7899        '''
7900         True if the datasource is reachable and the credentials are valid.
7901        '''
7902        self.hostname = hostname if hostname is not None else ''
7903        self.id = id if id is not None else ''
7904        '''
7905         Unique identifier of the Resource.
7906        '''
7907        self.name = name if name is not None else ''
7908        '''
7909         Unique human-readable name of the Resource.
7910        '''
7911        self.password = password if password is not None else ''
7912        self.port = port if port is not None else 0
7913        self.port_override = port_override if port_override is not None else 0
7914        self.replica_set = replica_set if replica_set is not None else ''
7915        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7916        '''
7917         ID of the secret store containing credentials for this resource, if any.
7918        '''
7919        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7920        '''
7921         Tags is a map of key, value pairs.
7922        '''
7923        self.tls_required = tls_required if tls_required is not None else False
7924        self.username = username if username is not None else ''
7925
7926    def __repr__(self):
7927        return '<sdm.MongoReplicaSet ' + \
7928            'auth_database: ' + repr(self.auth_database) + ' ' +\
7929            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7930            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7931            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7932            'healthy: ' + repr(self.healthy) + ' ' +\
7933            'hostname: ' + repr(self.hostname) + ' ' +\
7934            'id: ' + repr(self.id) + ' ' +\
7935            'name: ' + repr(self.name) + ' ' +\
7936            'password: ' + repr(self.password) + ' ' +\
7937            'port: ' + repr(self.port) + ' ' +\
7938            'port_override: ' + repr(self.port_override) + ' ' +\
7939            'replica_set: ' + repr(self.replica_set) + ' ' +\
7940            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7941            'tags: ' + repr(self.tags) + ' ' +\
7942            'tls_required: ' + repr(self.tls_required) + ' ' +\
7943            'username: ' + repr(self.username) + ' ' +\
7944            '>'
7945
7946    def to_dict(self):
7947        return {
7948            'auth_database': self.auth_database,
7949            'bind_interface': self.bind_interface,
7950            'connect_to_replica': self.connect_to_replica,
7951            'egress_filter': self.egress_filter,
7952            'healthy': self.healthy,
7953            'hostname': self.hostname,
7954            'id': self.id,
7955            'name': self.name,
7956            'password': self.password,
7957            'port': self.port,
7958            'port_override': self.port_override,
7959            'replica_set': self.replica_set,
7960            'secret_store_id': self.secret_store_id,
7961            'tags': self.tags,
7962            'tls_required': self.tls_required,
7963            'username': self.username,
7964        }
7965
7966    @classmethod
7967    def from_dict(cls, d):
7968        return cls(
7969            auth_database=d.get('auth_database'),
7970            bind_interface=d.get('bind_interface'),
7971            connect_to_replica=d.get('connect_to_replica'),
7972            egress_filter=d.get('egress_filter'),
7973            healthy=d.get('healthy'),
7974            hostname=d.get('hostname'),
7975            id=d.get('id'),
7976            name=d.get('name'),
7977            password=d.get('password'),
7978            port=d.get('port'),
7979            port_override=d.get('port_override'),
7980            replica_set=d.get('replica_set'),
7981            secret_store_id=d.get('secret_store_id'),
7982            tags=d.get('tags'),
7983            tls_required=d.get('tls_required'),
7984            username=d.get('username'),
7985        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7869    def __init__(
7870        self,
7871        auth_database=None,
7872        bind_interface=None,
7873        connect_to_replica=None,
7874        egress_filter=None,
7875        healthy=None,
7876        hostname=None,
7877        id=None,
7878        name=None,
7879        password=None,
7880        port=None,
7881        port_override=None,
7882        replica_set=None,
7883        secret_store_id=None,
7884        tags=None,
7885        tls_required=None,
7886        username=None,
7887    ):
7888        self.auth_database = auth_database if auth_database is not None else ''
7889        self.bind_interface = bind_interface if bind_interface is not None else ''
7890        '''
7891         Bind interface
7892        '''
7893        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7894        self.egress_filter = egress_filter if egress_filter is not None else ''
7895        '''
7896         A filter applied to the routing logic to pin datasource to nodes.
7897        '''
7898        self.healthy = healthy if healthy is not None else False
7899        '''
7900         True if the datasource is reachable and the credentials are valid.
7901        '''
7902        self.hostname = hostname if hostname is not None else ''
7903        self.id = id if id is not None else ''
7904        '''
7905         Unique identifier of the Resource.
7906        '''
7907        self.name = name if name is not None else ''
7908        '''
7909         Unique human-readable name of the Resource.
7910        '''
7911        self.password = password if password is not None else ''
7912        self.port = port if port is not None else 0
7913        self.port_override = port_override if port_override is not None else 0
7914        self.replica_set = replica_set if replica_set is not None else ''
7915        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7916        '''
7917         ID of the secret store containing credentials for this resource, if any.
7918        '''
7919        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7920        '''
7921         Tags is a map of key, value pairs.
7922        '''
7923        self.tls_required = tls_required if tls_required is not None else False
7924        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7946    def to_dict(self):
7947        return {
7948            'auth_database': self.auth_database,
7949            'bind_interface': self.bind_interface,
7950            'connect_to_replica': self.connect_to_replica,
7951            'egress_filter': self.egress_filter,
7952            'healthy': self.healthy,
7953            'hostname': self.hostname,
7954            'id': self.id,
7955            'name': self.name,
7956            'password': self.password,
7957            'port': self.port,
7958            'port_override': self.port_override,
7959            'replica_set': self.replica_set,
7960            'secret_store_id': self.secret_store_id,
7961            'tags': self.tags,
7962            'tls_required': self.tls_required,
7963            'username': self.username,
7964        }
@classmethod
def from_dict(cls, d)
7966    @classmethod
7967    def from_dict(cls, d):
7968        return cls(
7969            auth_database=d.get('auth_database'),
7970            bind_interface=d.get('bind_interface'),
7971            connect_to_replica=d.get('connect_to_replica'),
7972            egress_filter=d.get('egress_filter'),
7973            healthy=d.get('healthy'),
7974            hostname=d.get('hostname'),
7975            id=d.get('id'),
7976            name=d.get('name'),
7977            password=d.get('password'),
7978            port=d.get('port'),
7979            port_override=d.get('port_override'),
7980            replica_set=d.get('replica_set'),
7981            secret_store_id=d.get('secret_store_id'),
7982            tags=d.get('tags'),
7983            tls_required=d.get('tls_required'),
7984            username=d.get('username'),
7985        )
class MongoShardedCluster:
7988class MongoShardedCluster:
7989    '''
7990    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
7991    without a major version bump.
7992    '''
7993    __slots__ = [
7994        'auth_database',
7995        'bind_interface',
7996        'egress_filter',
7997        'healthy',
7998        'hostname',
7999        'id',
8000        'name',
8001        'password',
8002        'port_override',
8003        'secret_store_id',
8004        'tags',
8005        'tls_required',
8006        'username',
8007    ]
8008
8009    def __init__(
8010        self,
8011        auth_database=None,
8012        bind_interface=None,
8013        egress_filter=None,
8014        healthy=None,
8015        hostname=None,
8016        id=None,
8017        name=None,
8018        password=None,
8019        port_override=None,
8020        secret_store_id=None,
8021        tags=None,
8022        tls_required=None,
8023        username=None,
8024    ):
8025        self.auth_database = auth_database if auth_database is not None else ''
8026        self.bind_interface = bind_interface if bind_interface is not None else ''
8027        '''
8028         Bind interface
8029        '''
8030        self.egress_filter = egress_filter if egress_filter is not None else ''
8031        '''
8032         A filter applied to the routing logic to pin datasource to nodes.
8033        '''
8034        self.healthy = healthy if healthy is not None else False
8035        '''
8036         True if the datasource is reachable and the credentials are valid.
8037        '''
8038        self.hostname = hostname if hostname is not None else ''
8039        self.id = id if id is not None else ''
8040        '''
8041         Unique identifier of the Resource.
8042        '''
8043        self.name = name if name is not None else ''
8044        '''
8045         Unique human-readable name of the Resource.
8046        '''
8047        self.password = password if password is not None else ''
8048        self.port_override = port_override if port_override is not None else 0
8049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8050        '''
8051         ID of the secret store containing credentials for this resource, if any.
8052        '''
8053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8054        '''
8055         Tags is a map of key, value pairs.
8056        '''
8057        self.tls_required = tls_required if tls_required is not None else False
8058        self.username = username if username is not None else ''
8059
8060    def __repr__(self):
8061        return '<sdm.MongoShardedCluster ' + \
8062            'auth_database: ' + repr(self.auth_database) + ' ' +\
8063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8065            'healthy: ' + repr(self.healthy) + ' ' +\
8066            'hostname: ' + repr(self.hostname) + ' ' +\
8067            'id: ' + repr(self.id) + ' ' +\
8068            'name: ' + repr(self.name) + ' ' +\
8069            'password: ' + repr(self.password) + ' ' +\
8070            'port_override: ' + repr(self.port_override) + ' ' +\
8071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8072            'tags: ' + repr(self.tags) + ' ' +\
8073            'tls_required: ' + repr(self.tls_required) + ' ' +\
8074            'username: ' + repr(self.username) + ' ' +\
8075            '>'
8076
8077    def to_dict(self):
8078        return {
8079            'auth_database': self.auth_database,
8080            'bind_interface': self.bind_interface,
8081            'egress_filter': self.egress_filter,
8082            'healthy': self.healthy,
8083            'hostname': self.hostname,
8084            'id': self.id,
8085            'name': self.name,
8086            'password': self.password,
8087            'port_override': self.port_override,
8088            'secret_store_id': self.secret_store_id,
8089            'tags': self.tags,
8090            'tls_required': self.tls_required,
8091            'username': self.username,
8092        }
8093
8094    @classmethod
8095    def from_dict(cls, d):
8096        return cls(
8097            auth_database=d.get('auth_database'),
8098            bind_interface=d.get('bind_interface'),
8099            egress_filter=d.get('egress_filter'),
8100            healthy=d.get('healthy'),
8101            hostname=d.get('hostname'),
8102            id=d.get('id'),
8103            name=d.get('name'),
8104            password=d.get('password'),
8105            port_override=d.get('port_override'),
8106            secret_store_id=d.get('secret_store_id'),
8107            tags=d.get('tags'),
8108            tls_required=d.get('tls_required'),
8109            username=d.get('username'),
8110        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8009    def __init__(
8010        self,
8011        auth_database=None,
8012        bind_interface=None,
8013        egress_filter=None,
8014        healthy=None,
8015        hostname=None,
8016        id=None,
8017        name=None,
8018        password=None,
8019        port_override=None,
8020        secret_store_id=None,
8021        tags=None,
8022        tls_required=None,
8023        username=None,
8024    ):
8025        self.auth_database = auth_database if auth_database is not None else ''
8026        self.bind_interface = bind_interface if bind_interface is not None else ''
8027        '''
8028         Bind interface
8029        '''
8030        self.egress_filter = egress_filter if egress_filter is not None else ''
8031        '''
8032         A filter applied to the routing logic to pin datasource to nodes.
8033        '''
8034        self.healthy = healthy if healthy is not None else False
8035        '''
8036         True if the datasource is reachable and the credentials are valid.
8037        '''
8038        self.hostname = hostname if hostname is not None else ''
8039        self.id = id if id is not None else ''
8040        '''
8041         Unique identifier of the Resource.
8042        '''
8043        self.name = name if name is not None else ''
8044        '''
8045         Unique human-readable name of the Resource.
8046        '''
8047        self.password = password if password is not None else ''
8048        self.port_override = port_override if port_override is not None else 0
8049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8050        '''
8051         ID of the secret store containing credentials for this resource, if any.
8052        '''
8053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8054        '''
8055         Tags is a map of key, value pairs.
8056        '''
8057        self.tls_required = tls_required if tls_required is not None else False
8058        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8077    def to_dict(self):
8078        return {
8079            'auth_database': self.auth_database,
8080            'bind_interface': self.bind_interface,
8081            'egress_filter': self.egress_filter,
8082            'healthy': self.healthy,
8083            'hostname': self.hostname,
8084            'id': self.id,
8085            'name': self.name,
8086            'password': self.password,
8087            'port_override': self.port_override,
8088            'secret_store_id': self.secret_store_id,
8089            'tags': self.tags,
8090            'tls_required': self.tls_required,
8091            'username': self.username,
8092        }
@classmethod
def from_dict(cls, d)
8094    @classmethod
8095    def from_dict(cls, d):
8096        return cls(
8097            auth_database=d.get('auth_database'),
8098            bind_interface=d.get('bind_interface'),
8099            egress_filter=d.get('egress_filter'),
8100            healthy=d.get('healthy'),
8101            hostname=d.get('hostname'),
8102            id=d.get('id'),
8103            name=d.get('name'),
8104            password=d.get('password'),
8105            port_override=d.get('port_override'),
8106            secret_store_id=d.get('secret_store_id'),
8107            tags=d.get('tags'),
8108            tls_required=d.get('tls_required'),
8109            username=d.get('username'),
8110        )
class Mysql:
8113class Mysql:
8114    __slots__ = [
8115        'bind_interface',
8116        'database',
8117        'egress_filter',
8118        'healthy',
8119        'hostname',
8120        'id',
8121        'name',
8122        'password',
8123        'port',
8124        'port_override',
8125        'secret_store_id',
8126        'tags',
8127        'username',
8128    ]
8129
8130    def __init__(
8131        self,
8132        bind_interface=None,
8133        database=None,
8134        egress_filter=None,
8135        healthy=None,
8136        hostname=None,
8137        id=None,
8138        name=None,
8139        password=None,
8140        port=None,
8141        port_override=None,
8142        secret_store_id=None,
8143        tags=None,
8144        username=None,
8145    ):
8146        self.bind_interface = bind_interface if bind_interface is not None else ''
8147        '''
8148         Bind interface
8149        '''
8150        self.database = database if database is not None else ''
8151        self.egress_filter = egress_filter if egress_filter is not None else ''
8152        '''
8153         A filter applied to the routing logic to pin datasource to nodes.
8154        '''
8155        self.healthy = healthy if healthy is not None else False
8156        '''
8157         True if the datasource is reachable and the credentials are valid.
8158        '''
8159        self.hostname = hostname if hostname is not None else ''
8160        self.id = id if id is not None else ''
8161        '''
8162         Unique identifier of the Resource.
8163        '''
8164        self.name = name if name is not None else ''
8165        '''
8166         Unique human-readable name of the Resource.
8167        '''
8168        self.password = password if password is not None else ''
8169        self.port = port if port is not None else 0
8170        self.port_override = port_override if port_override is not None else 0
8171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8172        '''
8173         ID of the secret store containing credentials for this resource, if any.
8174        '''
8175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8176        '''
8177         Tags is a map of key, value pairs.
8178        '''
8179        self.username = username if username is not None else ''
8180
8181    def __repr__(self):
8182        return '<sdm.Mysql ' + \
8183            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8184            'database: ' + repr(self.database) + ' ' +\
8185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8186            'healthy: ' + repr(self.healthy) + ' ' +\
8187            'hostname: ' + repr(self.hostname) + ' ' +\
8188            'id: ' + repr(self.id) + ' ' +\
8189            'name: ' + repr(self.name) + ' ' +\
8190            'password: ' + repr(self.password) + ' ' +\
8191            'port: ' + repr(self.port) + ' ' +\
8192            'port_override: ' + repr(self.port_override) + ' ' +\
8193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8194            'tags: ' + repr(self.tags) + ' ' +\
8195            'username: ' + repr(self.username) + ' ' +\
8196            '>'
8197
8198    def to_dict(self):
8199        return {
8200            'bind_interface': self.bind_interface,
8201            'database': self.database,
8202            'egress_filter': self.egress_filter,
8203            'healthy': self.healthy,
8204            'hostname': self.hostname,
8205            'id': self.id,
8206            'name': self.name,
8207            'password': self.password,
8208            'port': self.port,
8209            'port_override': self.port_override,
8210            'secret_store_id': self.secret_store_id,
8211            'tags': self.tags,
8212            'username': self.username,
8213        }
8214
8215    @classmethod
8216    def from_dict(cls, d):
8217        return cls(
8218            bind_interface=d.get('bind_interface'),
8219            database=d.get('database'),
8220            egress_filter=d.get('egress_filter'),
8221            healthy=d.get('healthy'),
8222            hostname=d.get('hostname'),
8223            id=d.get('id'),
8224            name=d.get('name'),
8225            password=d.get('password'),
8226            port=d.get('port'),
8227            port_override=d.get('port_override'),
8228            secret_store_id=d.get('secret_store_id'),
8229            tags=d.get('tags'),
8230            username=d.get('username'),
8231        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8130    def __init__(
8131        self,
8132        bind_interface=None,
8133        database=None,
8134        egress_filter=None,
8135        healthy=None,
8136        hostname=None,
8137        id=None,
8138        name=None,
8139        password=None,
8140        port=None,
8141        port_override=None,
8142        secret_store_id=None,
8143        tags=None,
8144        username=None,
8145    ):
8146        self.bind_interface = bind_interface if bind_interface is not None else ''
8147        '''
8148         Bind interface
8149        '''
8150        self.database = database if database is not None else ''
8151        self.egress_filter = egress_filter if egress_filter is not None else ''
8152        '''
8153         A filter applied to the routing logic to pin datasource to nodes.
8154        '''
8155        self.healthy = healthy if healthy is not None else False
8156        '''
8157         True if the datasource is reachable and the credentials are valid.
8158        '''
8159        self.hostname = hostname if hostname is not None else ''
8160        self.id = id if id is not None else ''
8161        '''
8162         Unique identifier of the Resource.
8163        '''
8164        self.name = name if name is not None else ''
8165        '''
8166         Unique human-readable name of the Resource.
8167        '''
8168        self.password = password if password is not None else ''
8169        self.port = port if port is not None else 0
8170        self.port_override = port_override if port_override is not None else 0
8171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8172        '''
8173         ID of the secret store containing credentials for this resource, if any.
8174        '''
8175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8176        '''
8177         Tags is a map of key, value pairs.
8178        '''
8179        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8198    def to_dict(self):
8199        return {
8200            'bind_interface': self.bind_interface,
8201            'database': self.database,
8202            'egress_filter': self.egress_filter,
8203            'healthy': self.healthy,
8204            'hostname': self.hostname,
8205            'id': self.id,
8206            'name': self.name,
8207            'password': self.password,
8208            'port': self.port,
8209            'port_override': self.port_override,
8210            'secret_store_id': self.secret_store_id,
8211            'tags': self.tags,
8212            'username': self.username,
8213        }
@classmethod
def from_dict(cls, d)
8215    @classmethod
8216    def from_dict(cls, d):
8217        return cls(
8218            bind_interface=d.get('bind_interface'),
8219            database=d.get('database'),
8220            egress_filter=d.get('egress_filter'),
8221            healthy=d.get('healthy'),
8222            hostname=d.get('hostname'),
8223            id=d.get('id'),
8224            name=d.get('name'),
8225            password=d.get('password'),
8226            port=d.get('port'),
8227            port_override=d.get('port_override'),
8228            secret_store_id=d.get('secret_store_id'),
8229            tags=d.get('tags'),
8230            username=d.get('username'),
8231        )
class Neptune:
8234class Neptune:
8235    __slots__ = [
8236        'bind_interface',
8237        'egress_filter',
8238        'endpoint',
8239        'healthy',
8240        'id',
8241        'name',
8242        'port',
8243        'port_override',
8244        'secret_store_id',
8245        'tags',
8246    ]
8247
8248    def __init__(
8249        self,
8250        bind_interface=None,
8251        egress_filter=None,
8252        endpoint=None,
8253        healthy=None,
8254        id=None,
8255        name=None,
8256        port=None,
8257        port_override=None,
8258        secret_store_id=None,
8259        tags=None,
8260    ):
8261        self.bind_interface = bind_interface if bind_interface is not None else ''
8262        '''
8263         Bind interface
8264        '''
8265        self.egress_filter = egress_filter if egress_filter is not None else ''
8266        '''
8267         A filter applied to the routing logic to pin datasource to nodes.
8268        '''
8269        self.endpoint = endpoint if endpoint is not None else ''
8270        self.healthy = healthy if healthy is not None else False
8271        '''
8272         True if the datasource is reachable and the credentials are valid.
8273        '''
8274        self.id = id if id is not None else ''
8275        '''
8276         Unique identifier of the Resource.
8277        '''
8278        self.name = name if name is not None else ''
8279        '''
8280         Unique human-readable name of the Resource.
8281        '''
8282        self.port = port if port is not None else 0
8283        self.port_override = port_override if port_override is not None else 0
8284        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8285        '''
8286         ID of the secret store containing credentials for this resource, if any.
8287        '''
8288        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8289        '''
8290         Tags is a map of key, value pairs.
8291        '''
8292
8293    def __repr__(self):
8294        return '<sdm.Neptune ' + \
8295            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8296            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8297            'endpoint: ' + repr(self.endpoint) + ' ' +\
8298            'healthy: ' + repr(self.healthy) + ' ' +\
8299            'id: ' + repr(self.id) + ' ' +\
8300            'name: ' + repr(self.name) + ' ' +\
8301            'port: ' + repr(self.port) + ' ' +\
8302            'port_override: ' + repr(self.port_override) + ' ' +\
8303            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8304            'tags: ' + repr(self.tags) + ' ' +\
8305            '>'
8306
8307    def to_dict(self):
8308        return {
8309            'bind_interface': self.bind_interface,
8310            'egress_filter': self.egress_filter,
8311            'endpoint': self.endpoint,
8312            'healthy': self.healthy,
8313            'id': self.id,
8314            'name': self.name,
8315            'port': self.port,
8316            'port_override': self.port_override,
8317            'secret_store_id': self.secret_store_id,
8318            'tags': self.tags,
8319        }
8320
8321    @classmethod
8322    def from_dict(cls, d):
8323        return cls(
8324            bind_interface=d.get('bind_interface'),
8325            egress_filter=d.get('egress_filter'),
8326            endpoint=d.get('endpoint'),
8327            healthy=d.get('healthy'),
8328            id=d.get('id'),
8329            name=d.get('name'),
8330            port=d.get('port'),
8331            port_override=d.get('port_override'),
8332            secret_store_id=d.get('secret_store_id'),
8333            tags=d.get('tags'),
8334        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8248    def __init__(
8249        self,
8250        bind_interface=None,
8251        egress_filter=None,
8252        endpoint=None,
8253        healthy=None,
8254        id=None,
8255        name=None,
8256        port=None,
8257        port_override=None,
8258        secret_store_id=None,
8259        tags=None,
8260    ):
8261        self.bind_interface = bind_interface if bind_interface is not None else ''
8262        '''
8263         Bind interface
8264        '''
8265        self.egress_filter = egress_filter if egress_filter is not None else ''
8266        '''
8267         A filter applied to the routing logic to pin datasource to nodes.
8268        '''
8269        self.endpoint = endpoint if endpoint is not None else ''
8270        self.healthy = healthy if healthy is not None else False
8271        '''
8272         True if the datasource is reachable and the credentials are valid.
8273        '''
8274        self.id = id if id is not None else ''
8275        '''
8276         Unique identifier of the Resource.
8277        '''
8278        self.name = name if name is not None else ''
8279        '''
8280         Unique human-readable name of the Resource.
8281        '''
8282        self.port = port if port is not None else 0
8283        self.port_override = port_override if port_override is not None else 0
8284        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8285        '''
8286         ID of the secret store containing credentials for this resource, if any.
8287        '''
8288        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8289        '''
8290         Tags is a map of key, value pairs.
8291        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8307    def to_dict(self):
8308        return {
8309            'bind_interface': self.bind_interface,
8310            'egress_filter': self.egress_filter,
8311            'endpoint': self.endpoint,
8312            'healthy': self.healthy,
8313            'id': self.id,
8314            'name': self.name,
8315            'port': self.port,
8316            'port_override': self.port_override,
8317            'secret_store_id': self.secret_store_id,
8318            'tags': self.tags,
8319        }
@classmethod
def from_dict(cls, d)
8321    @classmethod
8322    def from_dict(cls, d):
8323        return cls(
8324            bind_interface=d.get('bind_interface'),
8325            egress_filter=d.get('egress_filter'),
8326            endpoint=d.get('endpoint'),
8327            healthy=d.get('healthy'),
8328            id=d.get('id'),
8329            name=d.get('name'),
8330            port=d.get('port'),
8331            port_override=d.get('port_override'),
8332            secret_store_id=d.get('secret_store_id'),
8333            tags=d.get('tags'),
8334        )
class NeptuneIAM:
8337class NeptuneIAM:
8338    __slots__ = [
8339        'access_key',
8340        'bind_interface',
8341        'egress_filter',
8342        'endpoint',
8343        'healthy',
8344        'id',
8345        'name',
8346        'port',
8347        'port_override',
8348        'region',
8349        'role_arn',
8350        'role_external_id',
8351        'secret_access_key',
8352        'secret_store_id',
8353        'tags',
8354    ]
8355
8356    def __init__(
8357        self,
8358        access_key=None,
8359        bind_interface=None,
8360        egress_filter=None,
8361        endpoint=None,
8362        healthy=None,
8363        id=None,
8364        name=None,
8365        port=None,
8366        port_override=None,
8367        region=None,
8368        role_arn=None,
8369        role_external_id=None,
8370        secret_access_key=None,
8371        secret_store_id=None,
8372        tags=None,
8373    ):
8374        self.access_key = access_key if access_key is not None else ''
8375        self.bind_interface = bind_interface if bind_interface is not None else ''
8376        '''
8377         Bind interface
8378        '''
8379        self.egress_filter = egress_filter if egress_filter is not None else ''
8380        '''
8381         A filter applied to the routing logic to pin datasource to nodes.
8382        '''
8383        self.endpoint = endpoint if endpoint is not None else ''
8384        self.healthy = healthy if healthy is not None else False
8385        '''
8386         True if the datasource is reachable and the credentials are valid.
8387        '''
8388        self.id = id if id is not None else ''
8389        '''
8390         Unique identifier of the Resource.
8391        '''
8392        self.name = name if name is not None else ''
8393        '''
8394         Unique human-readable name of the Resource.
8395        '''
8396        self.port = port if port is not None else 0
8397        self.port_override = port_override if port_override is not None else 0
8398        self.region = region if region is not None else ''
8399        self.role_arn = role_arn if role_arn is not None else ''
8400        self.role_external_id = role_external_id if role_external_id is not None else ''
8401        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8402        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8403        '''
8404         ID of the secret store containing credentials for this resource, if any.
8405        '''
8406        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8407        '''
8408         Tags is a map of key, value pairs.
8409        '''
8410
8411    def __repr__(self):
8412        return '<sdm.NeptuneIAM ' + \
8413            'access_key: ' + repr(self.access_key) + ' ' +\
8414            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8415            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8416            'endpoint: ' + repr(self.endpoint) + ' ' +\
8417            'healthy: ' + repr(self.healthy) + ' ' +\
8418            'id: ' + repr(self.id) + ' ' +\
8419            'name: ' + repr(self.name) + ' ' +\
8420            'port: ' + repr(self.port) + ' ' +\
8421            'port_override: ' + repr(self.port_override) + ' ' +\
8422            'region: ' + repr(self.region) + ' ' +\
8423            'role_arn: ' + repr(self.role_arn) + ' ' +\
8424            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8425            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8426            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8427            'tags: ' + repr(self.tags) + ' ' +\
8428            '>'
8429
8430    def to_dict(self):
8431        return {
8432            'access_key': self.access_key,
8433            'bind_interface': self.bind_interface,
8434            'egress_filter': self.egress_filter,
8435            'endpoint': self.endpoint,
8436            'healthy': self.healthy,
8437            'id': self.id,
8438            'name': self.name,
8439            'port': self.port,
8440            'port_override': self.port_override,
8441            'region': self.region,
8442            'role_arn': self.role_arn,
8443            'role_external_id': self.role_external_id,
8444            'secret_access_key': self.secret_access_key,
8445            'secret_store_id': self.secret_store_id,
8446            'tags': self.tags,
8447        }
8448
8449    @classmethod
8450    def from_dict(cls, d):
8451        return cls(
8452            access_key=d.get('access_key'),
8453            bind_interface=d.get('bind_interface'),
8454            egress_filter=d.get('egress_filter'),
8455            endpoint=d.get('endpoint'),
8456            healthy=d.get('healthy'),
8457            id=d.get('id'),
8458            name=d.get('name'),
8459            port=d.get('port'),
8460            port_override=d.get('port_override'),
8461            region=d.get('region'),
8462            role_arn=d.get('role_arn'),
8463            role_external_id=d.get('role_external_id'),
8464            secret_access_key=d.get('secret_access_key'),
8465            secret_store_id=d.get('secret_store_id'),
8466            tags=d.get('tags'),
8467        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8356    def __init__(
8357        self,
8358        access_key=None,
8359        bind_interface=None,
8360        egress_filter=None,
8361        endpoint=None,
8362        healthy=None,
8363        id=None,
8364        name=None,
8365        port=None,
8366        port_override=None,
8367        region=None,
8368        role_arn=None,
8369        role_external_id=None,
8370        secret_access_key=None,
8371        secret_store_id=None,
8372        tags=None,
8373    ):
8374        self.access_key = access_key if access_key is not None else ''
8375        self.bind_interface = bind_interface if bind_interface is not None else ''
8376        '''
8377         Bind interface
8378        '''
8379        self.egress_filter = egress_filter if egress_filter is not None else ''
8380        '''
8381         A filter applied to the routing logic to pin datasource to nodes.
8382        '''
8383        self.endpoint = endpoint if endpoint is not None else ''
8384        self.healthy = healthy if healthy is not None else False
8385        '''
8386         True if the datasource is reachable and the credentials are valid.
8387        '''
8388        self.id = id if id is not None else ''
8389        '''
8390         Unique identifier of the Resource.
8391        '''
8392        self.name = name if name is not None else ''
8393        '''
8394         Unique human-readable name of the Resource.
8395        '''
8396        self.port = port if port is not None else 0
8397        self.port_override = port_override if port_override is not None else 0
8398        self.region = region if region is not None else ''
8399        self.role_arn = role_arn if role_arn is not None else ''
8400        self.role_external_id = role_external_id if role_external_id is not None else ''
8401        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8402        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8403        '''
8404         ID of the secret store containing credentials for this resource, if any.
8405        '''
8406        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8407        '''
8408         Tags is a map of key, value pairs.
8409        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8430    def to_dict(self):
8431        return {
8432            'access_key': self.access_key,
8433            'bind_interface': self.bind_interface,
8434            'egress_filter': self.egress_filter,
8435            'endpoint': self.endpoint,
8436            'healthy': self.healthy,
8437            'id': self.id,
8438            'name': self.name,
8439            'port': self.port,
8440            'port_override': self.port_override,
8441            'region': self.region,
8442            'role_arn': self.role_arn,
8443            'role_external_id': self.role_external_id,
8444            'secret_access_key': self.secret_access_key,
8445            'secret_store_id': self.secret_store_id,
8446            'tags': self.tags,
8447        }
@classmethod
def from_dict(cls, d)
8449    @classmethod
8450    def from_dict(cls, d):
8451        return cls(
8452            access_key=d.get('access_key'),
8453            bind_interface=d.get('bind_interface'),
8454            egress_filter=d.get('egress_filter'),
8455            endpoint=d.get('endpoint'),
8456            healthy=d.get('healthy'),
8457            id=d.get('id'),
8458            name=d.get('name'),
8459            port=d.get('port'),
8460            port_override=d.get('port_override'),
8461            region=d.get('region'),
8462            role_arn=d.get('role_arn'),
8463            role_external_id=d.get('role_external_id'),
8464            secret_access_key=d.get('secret_access_key'),
8465            secret_store_id=d.get('secret_store_id'),
8466            tags=d.get('tags'),
8467        )
class NodeCreateResponse:
8470class NodeCreateResponse:
8471    '''
8472         NodeCreateResponse reports how the Nodes were created in the system.
8473    '''
8474    __slots__ = [
8475        'meta',
8476        'node',
8477        'rate_limit',
8478        'token',
8479    ]
8480
8481    def __init__(
8482        self,
8483        meta=None,
8484        node=None,
8485        rate_limit=None,
8486        token=None,
8487    ):
8488        self.meta = meta if meta is not None else None
8489        '''
8490         Reserved for future use.
8491        '''
8492        self.node = node if node is not None else None
8493        '''
8494         The created Node.
8495        '''
8496        self.rate_limit = rate_limit if rate_limit is not None else None
8497        '''
8498         Rate limit information.
8499        '''
8500        self.token = token if token is not None else ''
8501        '''
8502         The auth token generated for the Node. The Node will use this token to
8503         authenticate with the strongDM API.
8504        '''
8505
8506    def __repr__(self):
8507        return '<sdm.NodeCreateResponse ' + \
8508            'meta: ' + repr(self.meta) + ' ' +\
8509            'node: ' + repr(self.node) + ' ' +\
8510            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8511            'token: ' + repr(self.token) + ' ' +\
8512            '>'
8513
8514    def to_dict(self):
8515        return {
8516            'meta': self.meta,
8517            'node': self.node,
8518            'rate_limit': self.rate_limit,
8519            'token': self.token,
8520        }
8521
8522    @classmethod
8523    def from_dict(cls, d):
8524        return cls(
8525            meta=d.get('meta'),
8526            node=d.get('node'),
8527            rate_limit=d.get('rate_limit'),
8528            token=d.get('token'),
8529        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8481    def __init__(
8482        self,
8483        meta=None,
8484        node=None,
8485        rate_limit=None,
8486        token=None,
8487    ):
8488        self.meta = meta if meta is not None else None
8489        '''
8490         Reserved for future use.
8491        '''
8492        self.node = node if node is not None else None
8493        '''
8494         The created Node.
8495        '''
8496        self.rate_limit = rate_limit if rate_limit is not None else None
8497        '''
8498         Rate limit information.
8499        '''
8500        self.token = token if token is not None else ''
8501        '''
8502         The auth token generated for the Node. The Node will use this token to
8503         authenticate with the strongDM API.
8504        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8514    def to_dict(self):
8515        return {
8516            'meta': self.meta,
8517            'node': self.node,
8518            'rate_limit': self.rate_limit,
8519            'token': self.token,
8520        }
@classmethod
def from_dict(cls, d)
8522    @classmethod
8523    def from_dict(cls, d):
8524        return cls(
8525            meta=d.get('meta'),
8526            node=d.get('node'),
8527            rate_limit=d.get('rate_limit'),
8528            token=d.get('token'),
8529        )
class NodeDeleteResponse:
8532class NodeDeleteResponse:
8533    '''
8534         NodeDeleteResponse returns information about a Node that was deleted.
8535    '''
8536    __slots__ = [
8537        'meta',
8538        'rate_limit',
8539    ]
8540
8541    def __init__(
8542        self,
8543        meta=None,
8544        rate_limit=None,
8545    ):
8546        self.meta = meta if meta is not None else None
8547        '''
8548         Reserved for future use.
8549        '''
8550        self.rate_limit = rate_limit if rate_limit is not None else None
8551        '''
8552         Rate limit information.
8553        '''
8554
8555    def __repr__(self):
8556        return '<sdm.NodeDeleteResponse ' + \
8557            'meta: ' + repr(self.meta) + ' ' +\
8558            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8559            '>'
8560
8561    def to_dict(self):
8562        return {
8563            'meta': self.meta,
8564            'rate_limit': self.rate_limit,
8565        }
8566
8567    @classmethod
8568    def from_dict(cls, d):
8569        return cls(
8570            meta=d.get('meta'),
8571            rate_limit=d.get('rate_limit'),
8572        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8541    def __init__(
8542        self,
8543        meta=None,
8544        rate_limit=None,
8545    ):
8546        self.meta = meta if meta is not None else None
8547        '''
8548         Reserved for future use.
8549        '''
8550        self.rate_limit = rate_limit if rate_limit is not None else None
8551        '''
8552         Rate limit information.
8553        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8561    def to_dict(self):
8562        return {
8563            'meta': self.meta,
8564            'rate_limit': self.rate_limit,
8565        }
@classmethod
def from_dict(cls, d)
8567    @classmethod
8568    def from_dict(cls, d):
8569        return cls(
8570            meta=d.get('meta'),
8571            rate_limit=d.get('rate_limit'),
8572        )
class NodeGetResponse:
8575class NodeGetResponse:
8576    '''
8577         NodeGetResponse returns a requested Node.
8578    '''
8579    __slots__ = [
8580        'meta',
8581        'node',
8582        'rate_limit',
8583    ]
8584
8585    def __init__(
8586        self,
8587        meta=None,
8588        node=None,
8589        rate_limit=None,
8590    ):
8591        self.meta = meta if meta is not None else None
8592        '''
8593         Reserved for future use.
8594        '''
8595        self.node = node if node is not None else None
8596        '''
8597         The requested Node.
8598        '''
8599        self.rate_limit = rate_limit if rate_limit is not None else None
8600        '''
8601         Rate limit information.
8602        '''
8603
8604    def __repr__(self):
8605        return '<sdm.NodeGetResponse ' + \
8606            'meta: ' + repr(self.meta) + ' ' +\
8607            'node: ' + repr(self.node) + ' ' +\
8608            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8609            '>'
8610
8611    def to_dict(self):
8612        return {
8613            'meta': self.meta,
8614            'node': self.node,
8615            'rate_limit': self.rate_limit,
8616        }
8617
8618    @classmethod
8619    def from_dict(cls, d):
8620        return cls(
8621            meta=d.get('meta'),
8622            node=d.get('node'),
8623            rate_limit=d.get('rate_limit'),
8624        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8585    def __init__(
8586        self,
8587        meta=None,
8588        node=None,
8589        rate_limit=None,
8590    ):
8591        self.meta = meta if meta is not None else None
8592        '''
8593         Reserved for future use.
8594        '''
8595        self.node = node if node is not None else None
8596        '''
8597         The requested Node.
8598        '''
8599        self.rate_limit = rate_limit if rate_limit is not None else None
8600        '''
8601         Rate limit information.
8602        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8611    def to_dict(self):
8612        return {
8613            'meta': self.meta,
8614            'node': self.node,
8615            'rate_limit': self.rate_limit,
8616        }
@classmethod
def from_dict(cls, d)
8618    @classmethod
8619    def from_dict(cls, d):
8620        return cls(
8621            meta=d.get('meta'),
8622            node=d.get('node'),
8623            rate_limit=d.get('rate_limit'),
8624        )
class NodeUpdateResponse:
8627class NodeUpdateResponse:
8628    '''
8629         NodeUpdateResponse returns the fields of a Node after it has been updated by
8630     a NodeUpdateRequest.
8631    '''
8632    __slots__ = [
8633        'meta',
8634        'node',
8635        'rate_limit',
8636    ]
8637
8638    def __init__(
8639        self,
8640        meta=None,
8641        node=None,
8642        rate_limit=None,
8643    ):
8644        self.meta = meta if meta is not None else None
8645        '''
8646         Reserved for future use.
8647        '''
8648        self.node = node if node is not None else None
8649        '''
8650         The updated Node.
8651        '''
8652        self.rate_limit = rate_limit if rate_limit is not None else None
8653        '''
8654         Rate limit information.
8655        '''
8656
8657    def __repr__(self):
8658        return '<sdm.NodeUpdateResponse ' + \
8659            'meta: ' + repr(self.meta) + ' ' +\
8660            'node: ' + repr(self.node) + ' ' +\
8661            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8662            '>'
8663
8664    def to_dict(self):
8665        return {
8666            'meta': self.meta,
8667            'node': self.node,
8668            'rate_limit': self.rate_limit,
8669        }
8670
8671    @classmethod
8672    def from_dict(cls, d):
8673        return cls(
8674            meta=d.get('meta'),
8675            node=d.get('node'),
8676            rate_limit=d.get('rate_limit'),
8677        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8638    def __init__(
8639        self,
8640        meta=None,
8641        node=None,
8642        rate_limit=None,
8643    ):
8644        self.meta = meta if meta is not None else None
8645        '''
8646         Reserved for future use.
8647        '''
8648        self.node = node if node is not None else None
8649        '''
8650         The updated Node.
8651        '''
8652        self.rate_limit = rate_limit if rate_limit is not None else None
8653        '''
8654         Rate limit information.
8655        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8664    def to_dict(self):
8665        return {
8666            'meta': self.meta,
8667            'node': self.node,
8668            'rate_limit': self.rate_limit,
8669        }
@classmethod
def from_dict(cls, d)
8671    @classmethod
8672    def from_dict(cls, d):
8673        return cls(
8674            meta=d.get('meta'),
8675            node=d.get('node'),
8676            rate_limit=d.get('rate_limit'),
8677        )
class Oracle:
8680class Oracle:
8681    __slots__ = [
8682        'bind_interface',
8683        'database',
8684        'egress_filter',
8685        'healthy',
8686        'hostname',
8687        'id',
8688        'name',
8689        'password',
8690        'port',
8691        'port_override',
8692        'secret_store_id',
8693        'tags',
8694        'tls_required',
8695        'username',
8696    ]
8697
8698    def __init__(
8699        self,
8700        bind_interface=None,
8701        database=None,
8702        egress_filter=None,
8703        healthy=None,
8704        hostname=None,
8705        id=None,
8706        name=None,
8707        password=None,
8708        port=None,
8709        port_override=None,
8710        secret_store_id=None,
8711        tags=None,
8712        tls_required=None,
8713        username=None,
8714    ):
8715        self.bind_interface = bind_interface if bind_interface is not None else ''
8716        '''
8717         Bind interface
8718        '''
8719        self.database = database if database is not None else ''
8720        self.egress_filter = egress_filter if egress_filter is not None else ''
8721        '''
8722         A filter applied to the routing logic to pin datasource to nodes.
8723        '''
8724        self.healthy = healthy if healthy is not None else False
8725        '''
8726         True if the datasource is reachable and the credentials are valid.
8727        '''
8728        self.hostname = hostname if hostname is not None else ''
8729        self.id = id if id is not None else ''
8730        '''
8731         Unique identifier of the Resource.
8732        '''
8733        self.name = name if name is not None else ''
8734        '''
8735         Unique human-readable name of the Resource.
8736        '''
8737        self.password = password if password is not None else ''
8738        self.port = port if port is not None else 0
8739        self.port_override = port_override if port_override is not None else 0
8740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8741        '''
8742         ID of the secret store containing credentials for this resource, if any.
8743        '''
8744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8745        '''
8746         Tags is a map of key, value pairs.
8747        '''
8748        self.tls_required = tls_required if tls_required is not None else False
8749        self.username = username if username is not None else ''
8750
8751    def __repr__(self):
8752        return '<sdm.Oracle ' + \
8753            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8754            'database: ' + repr(self.database) + ' ' +\
8755            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8756            'healthy: ' + repr(self.healthy) + ' ' +\
8757            'hostname: ' + repr(self.hostname) + ' ' +\
8758            'id: ' + repr(self.id) + ' ' +\
8759            'name: ' + repr(self.name) + ' ' +\
8760            'password: ' + repr(self.password) + ' ' +\
8761            'port: ' + repr(self.port) + ' ' +\
8762            'port_override: ' + repr(self.port_override) + ' ' +\
8763            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8764            'tags: ' + repr(self.tags) + ' ' +\
8765            'tls_required: ' + repr(self.tls_required) + ' ' +\
8766            'username: ' + repr(self.username) + ' ' +\
8767            '>'
8768
8769    def to_dict(self):
8770        return {
8771            'bind_interface': self.bind_interface,
8772            'database': self.database,
8773            'egress_filter': self.egress_filter,
8774            'healthy': self.healthy,
8775            'hostname': self.hostname,
8776            'id': self.id,
8777            'name': self.name,
8778            'password': self.password,
8779            'port': self.port,
8780            'port_override': self.port_override,
8781            'secret_store_id': self.secret_store_id,
8782            'tags': self.tags,
8783            'tls_required': self.tls_required,
8784            'username': self.username,
8785        }
8786
8787    @classmethod
8788    def from_dict(cls, d):
8789        return cls(
8790            bind_interface=d.get('bind_interface'),
8791            database=d.get('database'),
8792            egress_filter=d.get('egress_filter'),
8793            healthy=d.get('healthy'),
8794            hostname=d.get('hostname'),
8795            id=d.get('id'),
8796            name=d.get('name'),
8797            password=d.get('password'),
8798            port=d.get('port'),
8799            port_override=d.get('port_override'),
8800            secret_store_id=d.get('secret_store_id'),
8801            tags=d.get('tags'),
8802            tls_required=d.get('tls_required'),
8803            username=d.get('username'),
8804        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8698    def __init__(
8699        self,
8700        bind_interface=None,
8701        database=None,
8702        egress_filter=None,
8703        healthy=None,
8704        hostname=None,
8705        id=None,
8706        name=None,
8707        password=None,
8708        port=None,
8709        port_override=None,
8710        secret_store_id=None,
8711        tags=None,
8712        tls_required=None,
8713        username=None,
8714    ):
8715        self.bind_interface = bind_interface if bind_interface is not None else ''
8716        '''
8717         Bind interface
8718        '''
8719        self.database = database if database is not None else ''
8720        self.egress_filter = egress_filter if egress_filter is not None else ''
8721        '''
8722         A filter applied to the routing logic to pin datasource to nodes.
8723        '''
8724        self.healthy = healthy if healthy is not None else False
8725        '''
8726         True if the datasource is reachable and the credentials are valid.
8727        '''
8728        self.hostname = hostname if hostname is not None else ''
8729        self.id = id if id is not None else ''
8730        '''
8731         Unique identifier of the Resource.
8732        '''
8733        self.name = name if name is not None else ''
8734        '''
8735         Unique human-readable name of the Resource.
8736        '''
8737        self.password = password if password is not None else ''
8738        self.port = port if port is not None else 0
8739        self.port_override = port_override if port_override is not None else 0
8740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8741        '''
8742         ID of the secret store containing credentials for this resource, if any.
8743        '''
8744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8745        '''
8746         Tags is a map of key, value pairs.
8747        '''
8748        self.tls_required = tls_required if tls_required is not None else False
8749        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8769    def to_dict(self):
8770        return {
8771            'bind_interface': self.bind_interface,
8772            'database': self.database,
8773            'egress_filter': self.egress_filter,
8774            'healthy': self.healthy,
8775            'hostname': self.hostname,
8776            'id': self.id,
8777            'name': self.name,
8778            'password': self.password,
8779            'port': self.port,
8780            'port_override': self.port_override,
8781            'secret_store_id': self.secret_store_id,
8782            'tags': self.tags,
8783            'tls_required': self.tls_required,
8784            'username': self.username,
8785        }
@classmethod
def from_dict(cls, d)
8787    @classmethod
8788    def from_dict(cls, d):
8789        return cls(
8790            bind_interface=d.get('bind_interface'),
8791            database=d.get('database'),
8792            egress_filter=d.get('egress_filter'),
8793            healthy=d.get('healthy'),
8794            hostname=d.get('hostname'),
8795            id=d.get('id'),
8796            name=d.get('name'),
8797            password=d.get('password'),
8798            port=d.get('port'),
8799            port_override=d.get('port_override'),
8800            secret_store_id=d.get('secret_store_id'),
8801            tags=d.get('tags'),
8802            tls_required=d.get('tls_required'),
8803            username=d.get('username'),
8804        )
class Postgres:
8807class Postgres:
8808    __slots__ = [
8809        'bind_interface',
8810        'database',
8811        'egress_filter',
8812        'healthy',
8813        'hostname',
8814        'id',
8815        'name',
8816        'override_database',
8817        'password',
8818        'port',
8819        'port_override',
8820        'secret_store_id',
8821        'tags',
8822        'username',
8823    ]
8824
8825    def __init__(
8826        self,
8827        bind_interface=None,
8828        database=None,
8829        egress_filter=None,
8830        healthy=None,
8831        hostname=None,
8832        id=None,
8833        name=None,
8834        override_database=None,
8835        password=None,
8836        port=None,
8837        port_override=None,
8838        secret_store_id=None,
8839        tags=None,
8840        username=None,
8841    ):
8842        self.bind_interface = bind_interface if bind_interface is not None else ''
8843        '''
8844         Bind interface
8845        '''
8846        self.database = database if database is not None else ''
8847        self.egress_filter = egress_filter if egress_filter is not None else ''
8848        '''
8849         A filter applied to the routing logic to pin datasource to nodes.
8850        '''
8851        self.healthy = healthy if healthy is not None else False
8852        '''
8853         True if the datasource is reachable and the credentials are valid.
8854        '''
8855        self.hostname = hostname if hostname is not None else ''
8856        self.id = id if id is not None else ''
8857        '''
8858         Unique identifier of the Resource.
8859        '''
8860        self.name = name if name is not None else ''
8861        '''
8862         Unique human-readable name of the Resource.
8863        '''
8864        self.override_database = override_database if override_database is not None else False
8865        self.password = password if password is not None else ''
8866        self.port = port if port is not None else 0
8867        self.port_override = port_override if port_override is not None else 0
8868        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8869        '''
8870         ID of the secret store containing credentials for this resource, if any.
8871        '''
8872        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8873        '''
8874         Tags is a map of key, value pairs.
8875        '''
8876        self.username = username if username is not None else ''
8877
8878    def __repr__(self):
8879        return '<sdm.Postgres ' + \
8880            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8881            'database: ' + repr(self.database) + ' ' +\
8882            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8883            'healthy: ' + repr(self.healthy) + ' ' +\
8884            'hostname: ' + repr(self.hostname) + ' ' +\
8885            'id: ' + repr(self.id) + ' ' +\
8886            'name: ' + repr(self.name) + ' ' +\
8887            'override_database: ' + repr(self.override_database) + ' ' +\
8888            'password: ' + repr(self.password) + ' ' +\
8889            'port: ' + repr(self.port) + ' ' +\
8890            'port_override: ' + repr(self.port_override) + ' ' +\
8891            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8892            'tags: ' + repr(self.tags) + ' ' +\
8893            'username: ' + repr(self.username) + ' ' +\
8894            '>'
8895
8896    def to_dict(self):
8897        return {
8898            'bind_interface': self.bind_interface,
8899            'database': self.database,
8900            'egress_filter': self.egress_filter,
8901            'healthy': self.healthy,
8902            'hostname': self.hostname,
8903            'id': self.id,
8904            'name': self.name,
8905            'override_database': self.override_database,
8906            'password': self.password,
8907            'port': self.port,
8908            'port_override': self.port_override,
8909            'secret_store_id': self.secret_store_id,
8910            'tags': self.tags,
8911            'username': self.username,
8912        }
8913
8914    @classmethod
8915    def from_dict(cls, d):
8916        return cls(
8917            bind_interface=d.get('bind_interface'),
8918            database=d.get('database'),
8919            egress_filter=d.get('egress_filter'),
8920            healthy=d.get('healthy'),
8921            hostname=d.get('hostname'),
8922            id=d.get('id'),
8923            name=d.get('name'),
8924            override_database=d.get('override_database'),
8925            password=d.get('password'),
8926            port=d.get('port'),
8927            port_override=d.get('port_override'),
8928            secret_store_id=d.get('secret_store_id'),
8929            tags=d.get('tags'),
8930            username=d.get('username'),
8931        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8825    def __init__(
8826        self,
8827        bind_interface=None,
8828        database=None,
8829        egress_filter=None,
8830        healthy=None,
8831        hostname=None,
8832        id=None,
8833        name=None,
8834        override_database=None,
8835        password=None,
8836        port=None,
8837        port_override=None,
8838        secret_store_id=None,
8839        tags=None,
8840        username=None,
8841    ):
8842        self.bind_interface = bind_interface if bind_interface is not None else ''
8843        '''
8844         Bind interface
8845        '''
8846        self.database = database if database is not None else ''
8847        self.egress_filter = egress_filter if egress_filter is not None else ''
8848        '''
8849         A filter applied to the routing logic to pin datasource to nodes.
8850        '''
8851        self.healthy = healthy if healthy is not None else False
8852        '''
8853         True if the datasource is reachable and the credentials are valid.
8854        '''
8855        self.hostname = hostname if hostname is not None else ''
8856        self.id = id if id is not None else ''
8857        '''
8858         Unique identifier of the Resource.
8859        '''
8860        self.name = name if name is not None else ''
8861        '''
8862         Unique human-readable name of the Resource.
8863        '''
8864        self.override_database = override_database if override_database is not None else False
8865        self.password = password if password is not None else ''
8866        self.port = port if port is not None else 0
8867        self.port_override = port_override if port_override is not None else 0
8868        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8869        '''
8870         ID of the secret store containing credentials for this resource, if any.
8871        '''
8872        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8873        '''
8874         Tags is a map of key, value pairs.
8875        '''
8876        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8896    def to_dict(self):
8897        return {
8898            'bind_interface': self.bind_interface,
8899            'database': self.database,
8900            'egress_filter': self.egress_filter,
8901            'healthy': self.healthy,
8902            'hostname': self.hostname,
8903            'id': self.id,
8904            'name': self.name,
8905            'override_database': self.override_database,
8906            'password': self.password,
8907            'port': self.port,
8908            'port_override': self.port_override,
8909            'secret_store_id': self.secret_store_id,
8910            'tags': self.tags,
8911            'username': self.username,
8912        }
@classmethod
def from_dict(cls, d)
8914    @classmethod
8915    def from_dict(cls, d):
8916        return cls(
8917            bind_interface=d.get('bind_interface'),
8918            database=d.get('database'),
8919            egress_filter=d.get('egress_filter'),
8920            healthy=d.get('healthy'),
8921            hostname=d.get('hostname'),
8922            id=d.get('id'),
8923            name=d.get('name'),
8924            override_database=d.get('override_database'),
8925            password=d.get('password'),
8926            port=d.get('port'),
8927            port_override=d.get('port_override'),
8928            secret_store_id=d.get('secret_store_id'),
8929            tags=d.get('tags'),
8930            username=d.get('username'),
8931        )
class Presto:
8934class Presto:
8935    __slots__ = [
8936        'bind_interface',
8937        'database',
8938        'egress_filter',
8939        'healthy',
8940        'hostname',
8941        'id',
8942        'name',
8943        'password',
8944        'port',
8945        'port_override',
8946        'secret_store_id',
8947        'tags',
8948        'tls_required',
8949        'username',
8950    ]
8951
8952    def __init__(
8953        self,
8954        bind_interface=None,
8955        database=None,
8956        egress_filter=None,
8957        healthy=None,
8958        hostname=None,
8959        id=None,
8960        name=None,
8961        password=None,
8962        port=None,
8963        port_override=None,
8964        secret_store_id=None,
8965        tags=None,
8966        tls_required=None,
8967        username=None,
8968    ):
8969        self.bind_interface = bind_interface if bind_interface is not None else ''
8970        '''
8971         Bind interface
8972        '''
8973        self.database = database if database is not None else ''
8974        self.egress_filter = egress_filter if egress_filter is not None else ''
8975        '''
8976         A filter applied to the routing logic to pin datasource to nodes.
8977        '''
8978        self.healthy = healthy if healthy is not None else False
8979        '''
8980         True if the datasource is reachable and the credentials are valid.
8981        '''
8982        self.hostname = hostname if hostname is not None else ''
8983        self.id = id if id is not None else ''
8984        '''
8985         Unique identifier of the Resource.
8986        '''
8987        self.name = name if name is not None else ''
8988        '''
8989         Unique human-readable name of the Resource.
8990        '''
8991        self.password = password if password is not None else ''
8992        self.port = port if port is not None else 0
8993        self.port_override = port_override if port_override is not None else 0
8994        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8995        '''
8996         ID of the secret store containing credentials for this resource, if any.
8997        '''
8998        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8999        '''
9000         Tags is a map of key, value pairs.
9001        '''
9002        self.tls_required = tls_required if tls_required is not None else False
9003        self.username = username if username is not None else ''
9004
9005    def __repr__(self):
9006        return '<sdm.Presto ' + \
9007            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9008            'database: ' + repr(self.database) + ' ' +\
9009            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9010            'healthy: ' + repr(self.healthy) + ' ' +\
9011            'hostname: ' + repr(self.hostname) + ' ' +\
9012            'id: ' + repr(self.id) + ' ' +\
9013            'name: ' + repr(self.name) + ' ' +\
9014            'password: ' + repr(self.password) + ' ' +\
9015            'port: ' + repr(self.port) + ' ' +\
9016            'port_override: ' + repr(self.port_override) + ' ' +\
9017            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9018            'tags: ' + repr(self.tags) + ' ' +\
9019            'tls_required: ' + repr(self.tls_required) + ' ' +\
9020            'username: ' + repr(self.username) + ' ' +\
9021            '>'
9022
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'database': self.database,
9027            'egress_filter': self.egress_filter,
9028            'healthy': self.healthy,
9029            'hostname': self.hostname,
9030            'id': self.id,
9031            'name': self.name,
9032            'password': self.password,
9033            'port': self.port,
9034            'port_override': self.port_override,
9035            'secret_store_id': self.secret_store_id,
9036            'tags': self.tags,
9037            'tls_required': self.tls_required,
9038            'username': self.username,
9039        }
9040
9041    @classmethod
9042    def from_dict(cls, d):
9043        return cls(
9044            bind_interface=d.get('bind_interface'),
9045            database=d.get('database'),
9046            egress_filter=d.get('egress_filter'),
9047            healthy=d.get('healthy'),
9048            hostname=d.get('hostname'),
9049            id=d.get('id'),
9050            name=d.get('name'),
9051            password=d.get('password'),
9052            port=d.get('port'),
9053            port_override=d.get('port_override'),
9054            secret_store_id=d.get('secret_store_id'),
9055            tags=d.get('tags'),
9056            tls_required=d.get('tls_required'),
9057            username=d.get('username'),
9058        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8952    def __init__(
8953        self,
8954        bind_interface=None,
8955        database=None,
8956        egress_filter=None,
8957        healthy=None,
8958        hostname=None,
8959        id=None,
8960        name=None,
8961        password=None,
8962        port=None,
8963        port_override=None,
8964        secret_store_id=None,
8965        tags=None,
8966        tls_required=None,
8967        username=None,
8968    ):
8969        self.bind_interface = bind_interface if bind_interface is not None else ''
8970        '''
8971         Bind interface
8972        '''
8973        self.database = database if database is not None else ''
8974        self.egress_filter = egress_filter if egress_filter is not None else ''
8975        '''
8976         A filter applied to the routing logic to pin datasource to nodes.
8977        '''
8978        self.healthy = healthy if healthy is not None else False
8979        '''
8980         True if the datasource is reachable and the credentials are valid.
8981        '''
8982        self.hostname = hostname if hostname is not None else ''
8983        self.id = id if id is not None else ''
8984        '''
8985         Unique identifier of the Resource.
8986        '''
8987        self.name = name if name is not None else ''
8988        '''
8989         Unique human-readable name of the Resource.
8990        '''
8991        self.password = password if password is not None else ''
8992        self.port = port if port is not None else 0
8993        self.port_override = port_override if port_override is not None else 0
8994        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8995        '''
8996         ID of the secret store containing credentials for this resource, if any.
8997        '''
8998        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8999        '''
9000         Tags is a map of key, value pairs.
9001        '''
9002        self.tls_required = tls_required if tls_required is not None else False
9003        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'database': self.database,
9027            'egress_filter': self.egress_filter,
9028            'healthy': self.healthy,
9029            'hostname': self.hostname,
9030            'id': self.id,
9031            'name': self.name,
9032            'password': self.password,
9033            'port': self.port,
9034            'port_override': self.port_override,
9035            'secret_store_id': self.secret_store_id,
9036            'tags': self.tags,
9037            'tls_required': self.tls_required,
9038            'username': self.username,
9039        }
@classmethod
def from_dict(cls, d)
9041    @classmethod
9042    def from_dict(cls, d):
9043        return cls(
9044            bind_interface=d.get('bind_interface'),
9045            database=d.get('database'),
9046            egress_filter=d.get('egress_filter'),
9047            healthy=d.get('healthy'),
9048            hostname=d.get('hostname'),
9049            id=d.get('id'),
9050            name=d.get('name'),
9051            password=d.get('password'),
9052            port=d.get('port'),
9053            port_override=d.get('port_override'),
9054            secret_store_id=d.get('secret_store_id'),
9055            tags=d.get('tags'),
9056            tls_required=d.get('tls_required'),
9057            username=d.get('username'),
9058        )
class RDP:
9061class RDP:
9062    __slots__ = [
9063        'bind_interface',
9064        'downgrade_nla_connections',
9065        'egress_filter',
9066        'healthy',
9067        'hostname',
9068        'id',
9069        'name',
9070        'password',
9071        'port',
9072        'port_override',
9073        'secret_store_id',
9074        'tags',
9075        'username',
9076    ]
9077
9078    def __init__(
9079        self,
9080        bind_interface=None,
9081        downgrade_nla_connections=None,
9082        egress_filter=None,
9083        healthy=None,
9084        hostname=None,
9085        id=None,
9086        name=None,
9087        password=None,
9088        port=None,
9089        port_override=None,
9090        secret_store_id=None,
9091        tags=None,
9092        username=None,
9093    ):
9094        self.bind_interface = bind_interface if bind_interface is not None else ''
9095        '''
9096         Bind interface
9097        '''
9098        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9099        self.egress_filter = egress_filter if egress_filter is not None else ''
9100        '''
9101         A filter applied to the routing logic to pin datasource to nodes.
9102        '''
9103        self.healthy = healthy if healthy is not None else False
9104        '''
9105         True if the datasource is reachable and the credentials are valid.
9106        '''
9107        self.hostname = hostname if hostname is not None else ''
9108        self.id = id if id is not None else ''
9109        '''
9110         Unique identifier of the Resource.
9111        '''
9112        self.name = name if name is not None else ''
9113        '''
9114         Unique human-readable name of the Resource.
9115        '''
9116        self.password = password if password is not None else ''
9117        self.port = port if port is not None else 0
9118        self.port_override = port_override if port_override is not None else 0
9119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9120        '''
9121         ID of the secret store containing credentials for this resource, if any.
9122        '''
9123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9124        '''
9125         Tags is a map of key, value pairs.
9126        '''
9127        self.username = username if username is not None else ''
9128
9129    def __repr__(self):
9130        return '<sdm.RDP ' + \
9131            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9132            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9133            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9134            'healthy: ' + repr(self.healthy) + ' ' +\
9135            'hostname: ' + repr(self.hostname) + ' ' +\
9136            'id: ' + repr(self.id) + ' ' +\
9137            'name: ' + repr(self.name) + ' ' +\
9138            'password: ' + repr(self.password) + ' ' +\
9139            'port: ' + repr(self.port) + ' ' +\
9140            'port_override: ' + repr(self.port_override) + ' ' +\
9141            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9142            'tags: ' + repr(self.tags) + ' ' +\
9143            'username: ' + repr(self.username) + ' ' +\
9144            '>'
9145
9146    def to_dict(self):
9147        return {
9148            'bind_interface': self.bind_interface,
9149            'downgrade_nla_connections': self.downgrade_nla_connections,
9150            'egress_filter': self.egress_filter,
9151            'healthy': self.healthy,
9152            'hostname': self.hostname,
9153            'id': self.id,
9154            'name': self.name,
9155            'password': self.password,
9156            'port': self.port,
9157            'port_override': self.port_override,
9158            'secret_store_id': self.secret_store_id,
9159            'tags': self.tags,
9160            'username': self.username,
9161        }
9162
9163    @classmethod
9164    def from_dict(cls, d):
9165        return cls(
9166            bind_interface=d.get('bind_interface'),
9167            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9168            egress_filter=d.get('egress_filter'),
9169            healthy=d.get('healthy'),
9170            hostname=d.get('hostname'),
9171            id=d.get('id'),
9172            name=d.get('name'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9078    def __init__(
9079        self,
9080        bind_interface=None,
9081        downgrade_nla_connections=None,
9082        egress_filter=None,
9083        healthy=None,
9084        hostname=None,
9085        id=None,
9086        name=None,
9087        password=None,
9088        port=None,
9089        port_override=None,
9090        secret_store_id=None,
9091        tags=None,
9092        username=None,
9093    ):
9094        self.bind_interface = bind_interface if bind_interface is not None else ''
9095        '''
9096         Bind interface
9097        '''
9098        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9099        self.egress_filter = egress_filter if egress_filter is not None else ''
9100        '''
9101         A filter applied to the routing logic to pin datasource to nodes.
9102        '''
9103        self.healthy = healthy if healthy is not None else False
9104        '''
9105         True if the datasource is reachable and the credentials are valid.
9106        '''
9107        self.hostname = hostname if hostname is not None else ''
9108        self.id = id if id is not None else ''
9109        '''
9110         Unique identifier of the Resource.
9111        '''
9112        self.name = name if name is not None else ''
9113        '''
9114         Unique human-readable name of the Resource.
9115        '''
9116        self.password = password if password is not None else ''
9117        self.port = port if port is not None else 0
9118        self.port_override = port_override if port_override is not None else 0
9119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9120        '''
9121         ID of the secret store containing credentials for this resource, if any.
9122        '''
9123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9124        '''
9125         Tags is a map of key, value pairs.
9126        '''
9127        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9146    def to_dict(self):
9147        return {
9148            'bind_interface': self.bind_interface,
9149            'downgrade_nla_connections': self.downgrade_nla_connections,
9150            'egress_filter': self.egress_filter,
9151            'healthy': self.healthy,
9152            'hostname': self.hostname,
9153            'id': self.id,
9154            'name': self.name,
9155            'password': self.password,
9156            'port': self.port,
9157            'port_override': self.port_override,
9158            'secret_store_id': self.secret_store_id,
9159            'tags': self.tags,
9160            'username': self.username,
9161        }
@classmethod
def from_dict(cls, d)
9163    @classmethod
9164    def from_dict(cls, d):
9165        return cls(
9166            bind_interface=d.get('bind_interface'),
9167            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9168            egress_filter=d.get('egress_filter'),
9169            healthy=d.get('healthy'),
9170            hostname=d.get('hostname'),
9171            id=d.get('id'),
9172            name=d.get('name'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
class RabbitMQAMQP091:
9182class RabbitMQAMQP091:
9183    __slots__ = [
9184        'bind_interface',
9185        'egress_filter',
9186        'healthy',
9187        'hostname',
9188        'id',
9189        'name',
9190        'password',
9191        'port',
9192        'port_override',
9193        'secret_store_id',
9194        'tags',
9195        'tls_required',
9196        'username',
9197    ]
9198
9199    def __init__(
9200        self,
9201        bind_interface=None,
9202        egress_filter=None,
9203        healthy=None,
9204        hostname=None,
9205        id=None,
9206        name=None,
9207        password=None,
9208        port=None,
9209        port_override=None,
9210        secret_store_id=None,
9211        tags=None,
9212        tls_required=None,
9213        username=None,
9214    ):
9215        self.bind_interface = bind_interface if bind_interface is not None else ''
9216        '''
9217         Bind interface
9218        '''
9219        self.egress_filter = egress_filter if egress_filter is not None else ''
9220        '''
9221         A filter applied to the routing logic to pin datasource to nodes.
9222        '''
9223        self.healthy = healthy if healthy is not None else False
9224        '''
9225         True if the datasource is reachable and the credentials are valid.
9226        '''
9227        self.hostname = hostname if hostname is not None else ''
9228        self.id = id if id is not None else ''
9229        '''
9230         Unique identifier of the Resource.
9231        '''
9232        self.name = name if name is not None else ''
9233        '''
9234         Unique human-readable name of the Resource.
9235        '''
9236        self.password = password if password is not None else ''
9237        self.port = port if port is not None else 0
9238        self.port_override = port_override if port_override is not None else 0
9239        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9240        '''
9241         ID of the secret store containing credentials for this resource, if any.
9242        '''
9243        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9244        '''
9245         Tags is a map of key, value pairs.
9246        '''
9247        self.tls_required = tls_required if tls_required is not None else False
9248        self.username = username if username is not None else ''
9249
9250    def __repr__(self):
9251        return '<sdm.RabbitMQAMQP091 ' + \
9252            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9253            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9254            'healthy: ' + repr(self.healthy) + ' ' +\
9255            'hostname: ' + repr(self.hostname) + ' ' +\
9256            'id: ' + repr(self.id) + ' ' +\
9257            'name: ' + repr(self.name) + ' ' +\
9258            'password: ' + repr(self.password) + ' ' +\
9259            'port: ' + repr(self.port) + ' ' +\
9260            'port_override: ' + repr(self.port_override) + ' ' +\
9261            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9262            'tags: ' + repr(self.tags) + ' ' +\
9263            'tls_required: ' + repr(self.tls_required) + ' ' +\
9264            'username: ' + repr(self.username) + ' ' +\
9265            '>'
9266
9267    def to_dict(self):
9268        return {
9269            'bind_interface': self.bind_interface,
9270            'egress_filter': self.egress_filter,
9271            'healthy': self.healthy,
9272            'hostname': self.hostname,
9273            'id': self.id,
9274            'name': self.name,
9275            'password': self.password,
9276            'port': self.port,
9277            'port_override': self.port_override,
9278            'secret_store_id': self.secret_store_id,
9279            'tags': self.tags,
9280            'tls_required': self.tls_required,
9281            'username': self.username,
9282        }
9283
9284    @classmethod
9285    def from_dict(cls, d):
9286        return cls(
9287            bind_interface=d.get('bind_interface'),
9288            egress_filter=d.get('egress_filter'),
9289            healthy=d.get('healthy'),
9290            hostname=d.get('hostname'),
9291            id=d.get('id'),
9292            name=d.get('name'),
9293            password=d.get('password'),
9294            port=d.get('port'),
9295            port_override=d.get('port_override'),
9296            secret_store_id=d.get('secret_store_id'),
9297            tags=d.get('tags'),
9298            tls_required=d.get('tls_required'),
9299            username=d.get('username'),
9300        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9199    def __init__(
9200        self,
9201        bind_interface=None,
9202        egress_filter=None,
9203        healthy=None,
9204        hostname=None,
9205        id=None,
9206        name=None,
9207        password=None,
9208        port=None,
9209        port_override=None,
9210        secret_store_id=None,
9211        tags=None,
9212        tls_required=None,
9213        username=None,
9214    ):
9215        self.bind_interface = bind_interface if bind_interface is not None else ''
9216        '''
9217         Bind interface
9218        '''
9219        self.egress_filter = egress_filter if egress_filter is not None else ''
9220        '''
9221         A filter applied to the routing logic to pin datasource to nodes.
9222        '''
9223        self.healthy = healthy if healthy is not None else False
9224        '''
9225         True if the datasource is reachable and the credentials are valid.
9226        '''
9227        self.hostname = hostname if hostname is not None else ''
9228        self.id = id if id is not None else ''
9229        '''
9230         Unique identifier of the Resource.
9231        '''
9232        self.name = name if name is not None else ''
9233        '''
9234         Unique human-readable name of the Resource.
9235        '''
9236        self.password = password if password is not None else ''
9237        self.port = port if port is not None else 0
9238        self.port_override = port_override if port_override is not None else 0
9239        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9240        '''
9241         ID of the secret store containing credentials for this resource, if any.
9242        '''
9243        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9244        '''
9245         Tags is a map of key, value pairs.
9246        '''
9247        self.tls_required = tls_required if tls_required is not None else False
9248        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9267    def to_dict(self):
9268        return {
9269            'bind_interface': self.bind_interface,
9270            'egress_filter': self.egress_filter,
9271            'healthy': self.healthy,
9272            'hostname': self.hostname,
9273            'id': self.id,
9274            'name': self.name,
9275            'password': self.password,
9276            'port': self.port,
9277            'port_override': self.port_override,
9278            'secret_store_id': self.secret_store_id,
9279            'tags': self.tags,
9280            'tls_required': self.tls_required,
9281            'username': self.username,
9282        }
@classmethod
def from_dict(cls, d)
9284    @classmethod
9285    def from_dict(cls, d):
9286        return cls(
9287            bind_interface=d.get('bind_interface'),
9288            egress_filter=d.get('egress_filter'),
9289            healthy=d.get('healthy'),
9290            hostname=d.get('hostname'),
9291            id=d.get('id'),
9292            name=d.get('name'),
9293            password=d.get('password'),
9294            port=d.get('port'),
9295            port_override=d.get('port_override'),
9296            secret_store_id=d.get('secret_store_id'),
9297            tags=d.get('tags'),
9298            tls_required=d.get('tls_required'),
9299            username=d.get('username'),
9300        )
class RateLimitMetadata:
9303class RateLimitMetadata:
9304    '''
9305         RateLimitMetadata contains information about remaining requests avaialable
9306     to the user over some timeframe.
9307    '''
9308    __slots__ = [
9309        'bucket',
9310        'limit',
9311        'remaining',
9312        'reset_at',
9313    ]
9314
9315    def __init__(
9316        self,
9317        bucket=None,
9318        limit=None,
9319        remaining=None,
9320        reset_at=None,
9321    ):
9322        self.bucket = bucket if bucket is not None else ''
9323        '''
9324         The bucket this user/token is associated with, which may be shared between
9325         multiple users/tokens.
9326        '''
9327        self.limit = limit if limit is not None else 0
9328        '''
9329         How many total requests the user/token is authorized to make before being
9330         rate limited.
9331        '''
9332        self.remaining = remaining if remaining is not None else 0
9333        '''
9334         How many remaining requests out of the limit are still avaialable.
9335        '''
9336        self.reset_at = reset_at if reset_at is not None else None
9337        '''
9338         The time when remaining will be reset to limit.
9339        '''
9340
9341    def __repr__(self):
9342        return '<sdm.RateLimitMetadata ' + \
9343            'bucket: ' + repr(self.bucket) + ' ' +\
9344            'limit: ' + repr(self.limit) + ' ' +\
9345            'remaining: ' + repr(self.remaining) + ' ' +\
9346            'reset_at: ' + repr(self.reset_at) + ' ' +\
9347            '>'
9348
9349    def to_dict(self):
9350        return {
9351            'bucket': self.bucket,
9352            'limit': self.limit,
9353            'remaining': self.remaining,
9354            'reset_at': self.reset_at,
9355        }
9356
9357    @classmethod
9358    def from_dict(cls, d):
9359        return cls(
9360            bucket=d.get('bucket'),
9361            limit=d.get('limit'),
9362            remaining=d.get('remaining'),
9363            reset_at=d.get('reset_at'),
9364        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9315    def __init__(
9316        self,
9317        bucket=None,
9318        limit=None,
9319        remaining=None,
9320        reset_at=None,
9321    ):
9322        self.bucket = bucket if bucket is not None else ''
9323        '''
9324         The bucket this user/token is associated with, which may be shared between
9325         multiple users/tokens.
9326        '''
9327        self.limit = limit if limit is not None else 0
9328        '''
9329         How many total requests the user/token is authorized to make before being
9330         rate limited.
9331        '''
9332        self.remaining = remaining if remaining is not None else 0
9333        '''
9334         How many remaining requests out of the limit are still avaialable.
9335        '''
9336        self.reset_at = reset_at if reset_at is not None else None
9337        '''
9338         The time when remaining will be reset to limit.
9339        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9349    def to_dict(self):
9350        return {
9351            'bucket': self.bucket,
9352            'limit': self.limit,
9353            'remaining': self.remaining,
9354            'reset_at': self.reset_at,
9355        }
@classmethod
def from_dict(cls, d)
9357    @classmethod
9358    def from_dict(cls, d):
9359        return cls(
9360            bucket=d.get('bucket'),
9361            limit=d.get('limit'),
9362            remaining=d.get('remaining'),
9363            reset_at=d.get('reset_at'),
9364        )
class RawTCP:
9367class RawTCP:
9368    __slots__ = [
9369        'bind_interface',
9370        'egress_filter',
9371        'healthy',
9372        'hostname',
9373        'id',
9374        'name',
9375        'port',
9376        'port_override',
9377        'secret_store_id',
9378        'tags',
9379    ]
9380
9381    def __init__(
9382        self,
9383        bind_interface=None,
9384        egress_filter=None,
9385        healthy=None,
9386        hostname=None,
9387        id=None,
9388        name=None,
9389        port=None,
9390        port_override=None,
9391        secret_store_id=None,
9392        tags=None,
9393    ):
9394        self.bind_interface = bind_interface if bind_interface is not None else ''
9395        '''
9396         Bind interface
9397        '''
9398        self.egress_filter = egress_filter if egress_filter is not None else ''
9399        '''
9400         A filter applied to the routing logic to pin datasource to nodes.
9401        '''
9402        self.healthy = healthy if healthy is not None else False
9403        '''
9404         True if the datasource is reachable and the credentials are valid.
9405        '''
9406        self.hostname = hostname if hostname is not None else ''
9407        self.id = id if id is not None else ''
9408        '''
9409         Unique identifier of the Resource.
9410        '''
9411        self.name = name if name is not None else ''
9412        '''
9413         Unique human-readable name of the Resource.
9414        '''
9415        self.port = port if port is not None else 0
9416        self.port_override = port_override if port_override is not None else 0
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
9425
9426    def __repr__(self):
9427        return '<sdm.RawTCP ' + \
9428            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9429            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9430            'healthy: ' + repr(self.healthy) + ' ' +\
9431            'hostname: ' + repr(self.hostname) + ' ' +\
9432            'id: ' + repr(self.id) + ' ' +\
9433            'name: ' + repr(self.name) + ' ' +\
9434            'port: ' + repr(self.port) + ' ' +\
9435            'port_override: ' + repr(self.port_override) + ' ' +\
9436            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9437            'tags: ' + repr(self.tags) + ' ' +\
9438            '>'
9439
9440    def to_dict(self):
9441        return {
9442            'bind_interface': self.bind_interface,
9443            'egress_filter': self.egress_filter,
9444            'healthy': self.healthy,
9445            'hostname': self.hostname,
9446            'id': self.id,
9447            'name': self.name,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
9453
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            bind_interface=d.get('bind_interface'),
9458            egress_filter=d.get('egress_filter'),
9459            healthy=d.get('healthy'),
9460            hostname=d.get('hostname'),
9461            id=d.get('id'),
9462            name=d.get('name'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9381    def __init__(
9382        self,
9383        bind_interface=None,
9384        egress_filter=None,
9385        healthy=None,
9386        hostname=None,
9387        id=None,
9388        name=None,
9389        port=None,
9390        port_override=None,
9391        secret_store_id=None,
9392        tags=None,
9393    ):
9394        self.bind_interface = bind_interface if bind_interface is not None else ''
9395        '''
9396         Bind interface
9397        '''
9398        self.egress_filter = egress_filter if egress_filter is not None else ''
9399        '''
9400         A filter applied to the routing logic to pin datasource to nodes.
9401        '''
9402        self.healthy = healthy if healthy is not None else False
9403        '''
9404         True if the datasource is reachable and the credentials are valid.
9405        '''
9406        self.hostname = hostname if hostname is not None else ''
9407        self.id = id if id is not None else ''
9408        '''
9409         Unique identifier of the Resource.
9410        '''
9411        self.name = name if name is not None else ''
9412        '''
9413         Unique human-readable name of the Resource.
9414        '''
9415        self.port = port if port is not None else 0
9416        self.port_override = port_override if port_override is not None else 0
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9440    def to_dict(self):
9441        return {
9442            'bind_interface': self.bind_interface,
9443            'egress_filter': self.egress_filter,
9444            'healthy': self.healthy,
9445            'hostname': self.hostname,
9446            'id': self.id,
9447            'name': self.name,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
@classmethod
def from_dict(cls, d)
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            bind_interface=d.get('bind_interface'),
9458            egress_filter=d.get('egress_filter'),
9459            healthy=d.get('healthy'),
9460            hostname=d.get('hostname'),
9461            id=d.get('id'),
9462            name=d.get('name'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
class Redis:
9470class Redis:
9471    __slots__ = [
9472        'bind_interface',
9473        'egress_filter',
9474        'healthy',
9475        'hostname',
9476        'id',
9477        'name',
9478        'password',
9479        'port',
9480        'port_override',
9481        'secret_store_id',
9482        'tags',
9483    ]
9484
9485    def __init__(
9486        self,
9487        bind_interface=None,
9488        egress_filter=None,
9489        healthy=None,
9490        hostname=None,
9491        id=None,
9492        name=None,
9493        password=None,
9494        port=None,
9495        port_override=None,
9496        secret_store_id=None,
9497        tags=None,
9498    ):
9499        self.bind_interface = bind_interface if bind_interface is not None else ''
9500        '''
9501         Bind interface
9502        '''
9503        self.egress_filter = egress_filter if egress_filter is not None else ''
9504        '''
9505         A filter applied to the routing logic to pin datasource to nodes.
9506        '''
9507        self.healthy = healthy if healthy is not None else False
9508        '''
9509         True if the datasource is reachable and the credentials are valid.
9510        '''
9511        self.hostname = hostname if hostname is not None else ''
9512        self.id = id if id is not None else ''
9513        '''
9514         Unique identifier of the Resource.
9515        '''
9516        self.name = name if name is not None else ''
9517        '''
9518         Unique human-readable name of the Resource.
9519        '''
9520        self.password = password if password is not None else ''
9521        self.port = port if port is not None else 0
9522        self.port_override = port_override if port_override is not None else 0
9523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9524        '''
9525         ID of the secret store containing credentials for this resource, if any.
9526        '''
9527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9528        '''
9529         Tags is a map of key, value pairs.
9530        '''
9531
9532    def __repr__(self):
9533        return '<sdm.Redis ' + \
9534            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9535            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9536            'healthy: ' + repr(self.healthy) + ' ' +\
9537            'hostname: ' + repr(self.hostname) + ' ' +\
9538            'id: ' + repr(self.id) + ' ' +\
9539            'name: ' + repr(self.name) + ' ' +\
9540            'password: ' + repr(self.password) + ' ' +\
9541            'port: ' + repr(self.port) + ' ' +\
9542            'port_override: ' + repr(self.port_override) + ' ' +\
9543            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9544            'tags: ' + repr(self.tags) + ' ' +\
9545            '>'
9546
9547    def to_dict(self):
9548        return {
9549            'bind_interface': self.bind_interface,
9550            'egress_filter': self.egress_filter,
9551            'healthy': self.healthy,
9552            'hostname': self.hostname,
9553            'id': self.id,
9554            'name': self.name,
9555            'password': self.password,
9556            'port': self.port,
9557            'port_override': self.port_override,
9558            'secret_store_id': self.secret_store_id,
9559            'tags': self.tags,
9560        }
9561
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bind_interface=d.get('bind_interface'),
9566            egress_filter=d.get('egress_filter'),
9567            healthy=d.get('healthy'),
9568            hostname=d.get('hostname'),
9569            id=d.get('id'),
9570            name=d.get('name'),
9571            password=d.get('password'),
9572            port=d.get('port'),
9573            port_override=d.get('port_override'),
9574            secret_store_id=d.get('secret_store_id'),
9575            tags=d.get('tags'),
9576        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
9485    def __init__(
9486        self,
9487        bind_interface=None,
9488        egress_filter=None,
9489        healthy=None,
9490        hostname=None,
9491        id=None,
9492        name=None,
9493        password=None,
9494        port=None,
9495        port_override=None,
9496        secret_store_id=None,
9497        tags=None,
9498    ):
9499        self.bind_interface = bind_interface if bind_interface is not None else ''
9500        '''
9501         Bind interface
9502        '''
9503        self.egress_filter = egress_filter if egress_filter is not None else ''
9504        '''
9505         A filter applied to the routing logic to pin datasource to nodes.
9506        '''
9507        self.healthy = healthy if healthy is not None else False
9508        '''
9509         True if the datasource is reachable and the credentials are valid.
9510        '''
9511        self.hostname = hostname if hostname is not None else ''
9512        self.id = id if id is not None else ''
9513        '''
9514         Unique identifier of the Resource.
9515        '''
9516        self.name = name if name is not None else ''
9517        '''
9518         Unique human-readable name of the Resource.
9519        '''
9520        self.password = password if password is not None else ''
9521        self.port = port if port is not None else 0
9522        self.port_override = port_override if port_override is not None else 0
9523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9524        '''
9525         ID of the secret store containing credentials for this resource, if any.
9526        '''
9527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9528        '''
9529         Tags is a map of key, value pairs.
9530        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9547    def to_dict(self):
9548        return {
9549            'bind_interface': self.bind_interface,
9550            'egress_filter': self.egress_filter,
9551            'healthy': self.healthy,
9552            'hostname': self.hostname,
9553            'id': self.id,
9554            'name': self.name,
9555            'password': self.password,
9556            'port': self.port,
9557            'port_override': self.port_override,
9558            'secret_store_id': self.secret_store_id,
9559            'tags': self.tags,
9560        }
@classmethod
def from_dict(cls, d)
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bind_interface=d.get('bind_interface'),
9566            egress_filter=d.get('egress_filter'),
9567            healthy=d.get('healthy'),
9568            hostname=d.get('hostname'),
9569            id=d.get('id'),
9570            name=d.get('name'),
9571            password=d.get('password'),
9572            port=d.get('port'),
9573            port_override=d.get('port_override'),
9574            secret_store_id=d.get('secret_store_id'),
9575            tags=d.get('tags'),
9576        )
class Redshift:
9579class Redshift:
9580    __slots__ = [
9581        'bind_interface',
9582        'database',
9583        'egress_filter',
9584        'healthy',
9585        'hostname',
9586        'id',
9587        'name',
9588        'override_database',
9589        'password',
9590        'port',
9591        'port_override',
9592        'secret_store_id',
9593        'tags',
9594        'username',
9595    ]
9596
9597    def __init__(
9598        self,
9599        bind_interface=None,
9600        database=None,
9601        egress_filter=None,
9602        healthy=None,
9603        hostname=None,
9604        id=None,
9605        name=None,
9606        override_database=None,
9607        password=None,
9608        port=None,
9609        port_override=None,
9610        secret_store_id=None,
9611        tags=None,
9612        username=None,
9613    ):
9614        self.bind_interface = bind_interface if bind_interface is not None else ''
9615        '''
9616         Bind interface
9617        '''
9618        self.database = database if database is not None else ''
9619        self.egress_filter = egress_filter if egress_filter is not None else ''
9620        '''
9621         A filter applied to the routing logic to pin datasource to nodes.
9622        '''
9623        self.healthy = healthy if healthy is not None else False
9624        '''
9625         True if the datasource is reachable and the credentials are valid.
9626        '''
9627        self.hostname = hostname if hostname is not None else ''
9628        self.id = id if id is not None else ''
9629        '''
9630         Unique identifier of the Resource.
9631        '''
9632        self.name = name if name is not None else ''
9633        '''
9634         Unique human-readable name of the Resource.
9635        '''
9636        self.override_database = override_database if override_database is not None else False
9637        self.password = password if password is not None else ''
9638        self.port = port if port is not None else 0
9639        self.port_override = port_override if port_override is not None else 0
9640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9641        '''
9642         ID of the secret store containing credentials for this resource, if any.
9643        '''
9644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9645        '''
9646         Tags is a map of key, value pairs.
9647        '''
9648        self.username = username if username is not None else ''
9649
9650    def __repr__(self):
9651        return '<sdm.Redshift ' + \
9652            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9653            'database: ' + repr(self.database) + ' ' +\
9654            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9655            'healthy: ' + repr(self.healthy) + ' ' +\
9656            'hostname: ' + repr(self.hostname) + ' ' +\
9657            'id: ' + repr(self.id) + ' ' +\
9658            'name: ' + repr(self.name) + ' ' +\
9659            'override_database: ' + repr(self.override_database) + ' ' +\
9660            'password: ' + repr(self.password) + ' ' +\
9661            'port: ' + repr(self.port) + ' ' +\
9662            'port_override: ' + repr(self.port_override) + ' ' +\
9663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9664            'tags: ' + repr(self.tags) + ' ' +\
9665            'username: ' + repr(self.username) + ' ' +\
9666            '>'
9667
9668    def to_dict(self):
9669        return {
9670            'bind_interface': self.bind_interface,
9671            'database': self.database,
9672            'egress_filter': self.egress_filter,
9673            'healthy': self.healthy,
9674            'hostname': self.hostname,
9675            'id': self.id,
9676            'name': self.name,
9677            'override_database': self.override_database,
9678            'password': self.password,
9679            'port': self.port,
9680            'port_override': self.port_override,
9681            'secret_store_id': self.secret_store_id,
9682            'tags': self.tags,
9683            'username': self.username,
9684        }
9685
9686    @classmethod
9687    def from_dict(cls, d):
9688        return cls(
9689            bind_interface=d.get('bind_interface'),
9690            database=d.get('database'),
9691            egress_filter=d.get('egress_filter'),
9692            healthy=d.get('healthy'),
9693            hostname=d.get('hostname'),
9694            id=d.get('id'),
9695            name=d.get('name'),
9696            override_database=d.get('override_database'),
9697            password=d.get('password'),
9698            port=d.get('port'),
9699            port_override=d.get('port_override'),
9700            secret_store_id=d.get('secret_store_id'),
9701            tags=d.get('tags'),
9702            username=d.get('username'),
9703        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9597    def __init__(
9598        self,
9599        bind_interface=None,
9600        database=None,
9601        egress_filter=None,
9602        healthy=None,
9603        hostname=None,
9604        id=None,
9605        name=None,
9606        override_database=None,
9607        password=None,
9608        port=None,
9609        port_override=None,
9610        secret_store_id=None,
9611        tags=None,
9612        username=None,
9613    ):
9614        self.bind_interface = bind_interface if bind_interface is not None else ''
9615        '''
9616         Bind interface
9617        '''
9618        self.database = database if database is not None else ''
9619        self.egress_filter = egress_filter if egress_filter is not None else ''
9620        '''
9621         A filter applied to the routing logic to pin datasource to nodes.
9622        '''
9623        self.healthy = healthy if healthy is not None else False
9624        '''
9625         True if the datasource is reachable and the credentials are valid.
9626        '''
9627        self.hostname = hostname if hostname is not None else ''
9628        self.id = id if id is not None else ''
9629        '''
9630         Unique identifier of the Resource.
9631        '''
9632        self.name = name if name is not None else ''
9633        '''
9634         Unique human-readable name of the Resource.
9635        '''
9636        self.override_database = override_database if override_database is not None else False
9637        self.password = password if password is not None else ''
9638        self.port = port if port is not None else 0
9639        self.port_override = port_override if port_override is not None else 0
9640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9641        '''
9642         ID of the secret store containing credentials for this resource, if any.
9643        '''
9644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9645        '''
9646         Tags is a map of key, value pairs.
9647        '''
9648        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9668    def to_dict(self):
9669        return {
9670            'bind_interface': self.bind_interface,
9671            'database': self.database,
9672            'egress_filter': self.egress_filter,
9673            'healthy': self.healthy,
9674            'hostname': self.hostname,
9675            'id': self.id,
9676            'name': self.name,
9677            'override_database': self.override_database,
9678            'password': self.password,
9679            'port': self.port,
9680            'port_override': self.port_override,
9681            'secret_store_id': self.secret_store_id,
9682            'tags': self.tags,
9683            'username': self.username,
9684        }
@classmethod
def from_dict(cls, d)
9686    @classmethod
9687    def from_dict(cls, d):
9688        return cls(
9689            bind_interface=d.get('bind_interface'),
9690            database=d.get('database'),
9691            egress_filter=d.get('egress_filter'),
9692            healthy=d.get('healthy'),
9693            hostname=d.get('hostname'),
9694            id=d.get('id'),
9695            name=d.get('name'),
9696            override_database=d.get('override_database'),
9697            password=d.get('password'),
9698            port=d.get('port'),
9699            port_override=d.get('port_override'),
9700            secret_store_id=d.get('secret_store_id'),
9701            tags=d.get('tags'),
9702            username=d.get('username'),
9703        )
class Relay:
9706class Relay:
9707    '''
9708         Relay represents a StrongDM CLI installation running in relay mode.
9709    '''
9710    __slots__ = [
9711        'device',
9712        'gateway_filter',
9713        'id',
9714        'location',
9715        'name',
9716        'state',
9717        'tags',
9718        'version',
9719    ]
9720
9721    def __init__(
9722        self,
9723        device=None,
9724        gateway_filter=None,
9725        id=None,
9726        location=None,
9727        name=None,
9728        state=None,
9729        tags=None,
9730        version=None,
9731    ):
9732        self.device = device if device is not None else ''
9733        '''
9734         Device is a read only device name uploaded by the gateway process when 
9735         it comes online.
9736        '''
9737        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9738        '''
9739         GatewayFilter can be used to restrict the peering between relays and
9740         gateways.
9741        '''
9742        self.id = id if id is not None else ''
9743        '''
9744         Unique identifier of the Relay.
9745        '''
9746        self.location = location if location is not None else ''
9747        '''
9748         Location is a read only network location uploaded by the gateway process
9749         when it comes online.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9754        '''
9755        self.state = state if state is not None else ''
9756        '''
9757         The current state of the relay. One of: "new", "verifying_restart",
9758         "awaiting_restart", "restarting", "started", "stopped", "dead",
9759         "unknown".
9760        '''
9761        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9762        '''
9763         Tags is a map of key, value pairs.
9764        '''
9765        self.version = version if version is not None else ''
9766        '''
9767         Version is a read only sdm binary version uploaded by the gateway process
9768         when it comes online.
9769        '''
9770
9771    def __repr__(self):
9772        return '<sdm.Relay ' + \
9773            'device: ' + repr(self.device) + ' ' +\
9774            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9775            'id: ' + repr(self.id) + ' ' +\
9776            'location: ' + repr(self.location) + ' ' +\
9777            'name: ' + repr(self.name) + ' ' +\
9778            'state: ' + repr(self.state) + ' ' +\
9779            'tags: ' + repr(self.tags) + ' ' +\
9780            'version: ' + repr(self.version) + ' ' +\
9781            '>'
9782
9783    def to_dict(self):
9784        return {
9785            'device': self.device,
9786            'gateway_filter': self.gateway_filter,
9787            'id': self.id,
9788            'location': self.location,
9789            'name': self.name,
9790            'state': self.state,
9791            'tags': self.tags,
9792            'version': self.version,
9793        }
9794
9795    @classmethod
9796    def from_dict(cls, d):
9797        return cls(
9798            device=d.get('device'),
9799            gateway_filter=d.get('gateway_filter'),
9800            id=d.get('id'),
9801            location=d.get('location'),
9802            name=d.get('name'),
9803            state=d.get('state'),
9804            tags=d.get('tags'),
9805            version=d.get('version'),
9806        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay( device=None, gateway_filter=None, id=None, location=None, name=None, state=None, tags=None, version=None)
9721    def __init__(
9722        self,
9723        device=None,
9724        gateway_filter=None,
9725        id=None,
9726        location=None,
9727        name=None,
9728        state=None,
9729        tags=None,
9730        version=None,
9731    ):
9732        self.device = device if device is not None else ''
9733        '''
9734         Device is a read only device name uploaded by the gateway process when 
9735         it comes online.
9736        '''
9737        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9738        '''
9739         GatewayFilter can be used to restrict the peering between relays and
9740         gateways.
9741        '''
9742        self.id = id if id is not None else ''
9743        '''
9744         Unique identifier of the Relay.
9745        '''
9746        self.location = location if location is not None else ''
9747        '''
9748         Location is a read only network location uploaded by the gateway process
9749         when it comes online.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9754        '''
9755        self.state = state if state is not None else ''
9756        '''
9757         The current state of the relay. One of: "new", "verifying_restart",
9758         "awaiting_restart", "restarting", "started", "stopped", "dead",
9759         "unknown".
9760        '''
9761        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9762        '''
9763         Tags is a map of key, value pairs.
9764        '''
9765        self.version = version if version is not None else ''
9766        '''
9767         Version is a read only sdm binary version uploaded by the gateway process
9768         when it comes online.
9769        '''
device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
9783    def to_dict(self):
9784        return {
9785            'device': self.device,
9786            'gateway_filter': self.gateway_filter,
9787            'id': self.id,
9788            'location': self.location,
9789            'name': self.name,
9790            'state': self.state,
9791            'tags': self.tags,
9792            'version': self.version,
9793        }
@classmethod
def from_dict(cls, d)
9795    @classmethod
9796    def from_dict(cls, d):
9797        return cls(
9798            device=d.get('device'),
9799            gateway_filter=d.get('gateway_filter'),
9800            id=d.get('id'),
9801            location=d.get('location'),
9802            name=d.get('name'),
9803            state=d.get('state'),
9804            tags=d.get('tags'),
9805            version=d.get('version'),
9806        )
class RemoteIdentity:
9809class RemoteIdentity:
9810    '''
9811         RemoteIdentities define the username to be used for a specific account
9812     when connecting to a remote resource using that group.
9813    '''
9814    __slots__ = [
9815        'account_id',
9816        'id',
9817        'remote_identity_group_id',
9818        'username',
9819    ]
9820
9821    def __init__(
9822        self,
9823        account_id=None,
9824        id=None,
9825        remote_identity_group_id=None,
9826        username=None,
9827    ):
9828        self.account_id = account_id if account_id is not None else ''
9829        '''
9830         The account for this remote identity.
9831        '''
9832        self.id = id if id is not None else ''
9833        '''
9834         Unique identifier of the RemoteIdentity.
9835        '''
9836        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9837        '''
9838         The remote identity group.
9839        '''
9840        self.username = username if username is not None else ''
9841        '''
9842         The username to be used as the remote identity for this account.
9843        '''
9844
9845    def __repr__(self):
9846        return '<sdm.RemoteIdentity ' + \
9847            'account_id: ' + repr(self.account_id) + ' ' +\
9848            'id: ' + repr(self.id) + ' ' +\
9849            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9850            'username: ' + repr(self.username) + ' ' +\
9851            '>'
9852
9853    def to_dict(self):
9854        return {
9855            'account_id': self.account_id,
9856            'id': self.id,
9857            'remote_identity_group_id': self.remote_identity_group_id,
9858            'username': self.username,
9859        }
9860
9861    @classmethod
9862    def from_dict(cls, d):
9863        return cls(
9864            account_id=d.get('account_id'),
9865            id=d.get('id'),
9866            remote_identity_group_id=d.get('remote_identity_group_id'),
9867            username=d.get('username'),
9868        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9821    def __init__(
9822        self,
9823        account_id=None,
9824        id=None,
9825        remote_identity_group_id=None,
9826        username=None,
9827    ):
9828        self.account_id = account_id if account_id is not None else ''
9829        '''
9830         The account for this remote identity.
9831        '''
9832        self.id = id if id is not None else ''
9833        '''
9834         Unique identifier of the RemoteIdentity.
9835        '''
9836        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9837        '''
9838         The remote identity group.
9839        '''
9840        self.username = username if username is not None else ''
9841        '''
9842         The username to be used as the remote identity for this account.
9843        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9853    def to_dict(self):
9854        return {
9855            'account_id': self.account_id,
9856            'id': self.id,
9857            'remote_identity_group_id': self.remote_identity_group_id,
9858            'username': self.username,
9859        }
@classmethod
def from_dict(cls, d)
9861    @classmethod
9862    def from_dict(cls, d):
9863        return cls(
9864            account_id=d.get('account_id'),
9865            id=d.get('id'),
9866            remote_identity_group_id=d.get('remote_identity_group_id'),
9867            username=d.get('username'),
9868        )
class RemoteIdentityCreateResponse:
9871class RemoteIdentityCreateResponse:
9872    '''
9873         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9874    '''
9875    __slots__ = [
9876        'meta',
9877        'rate_limit',
9878        'remote_identity',
9879    ]
9880
9881    def __init__(
9882        self,
9883        meta=None,
9884        rate_limit=None,
9885        remote_identity=None,
9886    ):
9887        self.meta = meta if meta is not None else None
9888        '''
9889         Reserved for future use.
9890        '''
9891        self.rate_limit = rate_limit if rate_limit is not None else None
9892        '''
9893         Rate limit information.
9894        '''
9895        self.remote_identity = remote_identity if remote_identity is not None else None
9896        '''
9897         The created RemoteIdentity.
9898        '''
9899
9900    def __repr__(self):
9901        return '<sdm.RemoteIdentityCreateResponse ' + \
9902            'meta: ' + repr(self.meta) + ' ' +\
9903            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9904            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9905            '>'
9906
9907    def to_dict(self):
9908        return {
9909            'meta': self.meta,
9910            'rate_limit': self.rate_limit,
9911            'remote_identity': self.remote_identity,
9912        }
9913
9914    @classmethod
9915    def from_dict(cls, d):
9916        return cls(
9917            meta=d.get('meta'),
9918            rate_limit=d.get('rate_limit'),
9919            remote_identity=d.get('remote_identity'),
9920        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9881    def __init__(
9882        self,
9883        meta=None,
9884        rate_limit=None,
9885        remote_identity=None,
9886    ):
9887        self.meta = meta if meta is not None else None
9888        '''
9889         Reserved for future use.
9890        '''
9891        self.rate_limit = rate_limit if rate_limit is not None else None
9892        '''
9893         Rate limit information.
9894        '''
9895        self.remote_identity = remote_identity if remote_identity is not None else None
9896        '''
9897         The created RemoteIdentity.
9898        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9907    def to_dict(self):
9908        return {
9909            'meta': self.meta,
9910            'rate_limit': self.rate_limit,
9911            'remote_identity': self.remote_identity,
9912        }
@classmethod
def from_dict(cls, d)
9914    @classmethod
9915    def from_dict(cls, d):
9916        return cls(
9917            meta=d.get('meta'),
9918            rate_limit=d.get('rate_limit'),
9919            remote_identity=d.get('remote_identity'),
9920        )
class RemoteIdentityDeleteResponse:
9923class RemoteIdentityDeleteResponse:
9924    '''
9925         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
9926    '''
9927    __slots__ = [
9928        'meta',
9929        'rate_limit',
9930    ]
9931
9932    def __init__(
9933        self,
9934        meta=None,
9935        rate_limit=None,
9936    ):
9937        self.meta = meta if meta is not None else None
9938        '''
9939         Reserved for future use.
9940        '''
9941        self.rate_limit = rate_limit if rate_limit is not None else None
9942        '''
9943         Rate limit information.
9944        '''
9945
9946    def __repr__(self):
9947        return '<sdm.RemoteIdentityDeleteResponse ' + \
9948            'meta: ' + repr(self.meta) + ' ' +\
9949            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9950            '>'
9951
9952    def to_dict(self):
9953        return {
9954            'meta': self.meta,
9955            'rate_limit': self.rate_limit,
9956        }
9957
9958    @classmethod
9959    def from_dict(cls, d):
9960        return cls(
9961            meta=d.get('meta'),
9962            rate_limit=d.get('rate_limit'),
9963        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
9932    def __init__(
9933        self,
9934        meta=None,
9935        rate_limit=None,
9936    ):
9937        self.meta = meta if meta is not None else None
9938        '''
9939         Reserved for future use.
9940        '''
9941        self.rate_limit = rate_limit if rate_limit is not None else None
9942        '''
9943         Rate limit information.
9944        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9952    def to_dict(self):
9953        return {
9954            'meta': self.meta,
9955            'rate_limit': self.rate_limit,
9956        }
@classmethod
def from_dict(cls, d)
9958    @classmethod
9959    def from_dict(cls, d):
9960        return cls(
9961            meta=d.get('meta'),
9962            rate_limit=d.get('rate_limit'),
9963        )
class RemoteIdentityGetResponse:
 9966class RemoteIdentityGetResponse:
 9967    '''
 9968         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9969    '''
 9970    __slots__ = [
 9971        'meta',
 9972        'rate_limit',
 9973        'remote_identity',
 9974    ]
 9975
 9976    def __init__(
 9977        self,
 9978        meta=None,
 9979        rate_limit=None,
 9980        remote_identity=None,
 9981    ):
 9982        self.meta = meta if meta is not None else None
 9983        '''
 9984         Reserved for future use.
 9985        '''
 9986        self.rate_limit = rate_limit if rate_limit is not None else None
 9987        '''
 9988         Rate limit information.
 9989        '''
 9990        self.remote_identity = remote_identity if remote_identity is not None else None
 9991        '''
 9992         The requested RemoteIdentity.
 9993        '''
 9994
 9995    def __repr__(self):
 9996        return '<sdm.RemoteIdentityGetResponse ' + \
 9997            'meta: ' + repr(self.meta) + ' ' +\
 9998            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9999            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10000            '>'
10001
10002    def to_dict(self):
10003        return {
10004            'meta': self.meta,
10005            'rate_limit': self.rate_limit,
10006            'remote_identity': self.remote_identity,
10007        }
10008
10009    @classmethod
10010    def from_dict(cls, d):
10011        return cls(
10012            meta=d.get('meta'),
10013            rate_limit=d.get('rate_limit'),
10014            remote_identity=d.get('remote_identity'),
10015        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
9976    def __init__(
9977        self,
9978        meta=None,
9979        rate_limit=None,
9980        remote_identity=None,
9981    ):
9982        self.meta = meta if meta is not None else None
9983        '''
9984         Reserved for future use.
9985        '''
9986        self.rate_limit = rate_limit if rate_limit is not None else None
9987        '''
9988         Rate limit information.
9989        '''
9990        self.remote_identity = remote_identity if remote_identity is not None else None
9991        '''
9992         The requested RemoteIdentity.
9993        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10002    def to_dict(self):
10003        return {
10004            'meta': self.meta,
10005            'rate_limit': self.rate_limit,
10006            'remote_identity': self.remote_identity,
10007        }
@classmethod
def from_dict(cls, d)
10009    @classmethod
10010    def from_dict(cls, d):
10011        return cls(
10012            meta=d.get('meta'),
10013            rate_limit=d.get('rate_limit'),
10014            remote_identity=d.get('remote_identity'),
10015        )
class RemoteIdentityGroup:
10018class RemoteIdentityGroup:
10019    '''
10020         A RemoteIdentityGroup defines a group of remote identities.
10021    '''
10022    __slots__ = [
10023        'id',
10024        'name',
10025    ]
10026
10027    def __init__(
10028        self,
10029        id=None,
10030        name=None,
10031    ):
10032        self.id = id if id is not None else ''
10033        '''
10034         Unique identifier of the RemoteIdentityGroup.
10035        '''
10036        self.name = name if name is not None else ''
10037        '''
10038         Unique human-readable name of the RemoteIdentityGroup.
10039        '''
10040
10041    def __repr__(self):
10042        return '<sdm.RemoteIdentityGroup ' + \
10043            'id: ' + repr(self.id) + ' ' +\
10044            'name: ' + repr(self.name) + ' ' +\
10045            '>'
10046
10047    def to_dict(self):
10048        return {
10049            'id': self.id,
10050            'name': self.name,
10051        }
10052
10053    @classmethod
10054    def from_dict(cls, d):
10055        return cls(
10056            id=d.get('id'),
10057            name=d.get('name'),
10058        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10027    def __init__(
10028        self,
10029        id=None,
10030        name=None,
10031    ):
10032        self.id = id if id is not None else ''
10033        '''
10034         Unique identifier of the RemoteIdentityGroup.
10035        '''
10036        self.name = name if name is not None else ''
10037        '''
10038         Unique human-readable name of the RemoteIdentityGroup.
10039        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10047    def to_dict(self):
10048        return {
10049            'id': self.id,
10050            'name': self.name,
10051        }
@classmethod
def from_dict(cls, d)
10053    @classmethod
10054    def from_dict(cls, d):
10055        return cls(
10056            id=d.get('id'),
10057            name=d.get('name'),
10058        )
class RemoteIdentityGroupGetResponse:
10061class RemoteIdentityGroupGetResponse:
10062    '''
10063         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10064    '''
10065    __slots__ = [
10066        'meta',
10067        'rate_limit',
10068        'remote_identity_group',
10069    ]
10070
10071    def __init__(
10072        self,
10073        meta=None,
10074        rate_limit=None,
10075        remote_identity_group=None,
10076    ):
10077        self.meta = meta if meta is not None else None
10078        '''
10079         Reserved for future use.
10080        '''
10081        self.rate_limit = rate_limit if rate_limit is not None else None
10082        '''
10083         Rate limit information.
10084        '''
10085        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10086        '''
10087         The requested RemoteIdentityGroup.
10088        '''
10089
10090    def __repr__(self):
10091        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10092            'meta: ' + repr(self.meta) + ' ' +\
10093            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10094            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10095            '>'
10096
10097    def to_dict(self):
10098        return {
10099            'meta': self.meta,
10100            'rate_limit': self.rate_limit,
10101            'remote_identity_group': self.remote_identity_group,
10102        }
10103
10104    @classmethod
10105    def from_dict(cls, d):
10106        return cls(
10107            meta=d.get('meta'),
10108            rate_limit=d.get('rate_limit'),
10109            remote_identity_group=d.get('remote_identity_group'),
10110        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10071    def __init__(
10072        self,
10073        meta=None,
10074        rate_limit=None,
10075        remote_identity_group=None,
10076    ):
10077        self.meta = meta if meta is not None else None
10078        '''
10079         Reserved for future use.
10080        '''
10081        self.rate_limit = rate_limit if rate_limit is not None else None
10082        '''
10083         Rate limit information.
10084        '''
10085        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10086        '''
10087         The requested RemoteIdentityGroup.
10088        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10097    def to_dict(self):
10098        return {
10099            'meta': self.meta,
10100            'rate_limit': self.rate_limit,
10101            'remote_identity_group': self.remote_identity_group,
10102        }
@classmethod
def from_dict(cls, d)
10104    @classmethod
10105    def from_dict(cls, d):
10106        return cls(
10107            meta=d.get('meta'),
10108            rate_limit=d.get('rate_limit'),
10109            remote_identity_group=d.get('remote_identity_group'),
10110        )
class RemoteIdentityUpdateResponse:
10113class RemoteIdentityUpdateResponse:
10114    '''
10115         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10116     a RemoteIdentityUpdateRequest.
10117    '''
10118    __slots__ = [
10119        'meta',
10120        'rate_limit',
10121        'remote_identity',
10122    ]
10123
10124    def __init__(
10125        self,
10126        meta=None,
10127        rate_limit=None,
10128        remote_identity=None,
10129    ):
10130        self.meta = meta if meta is not None else None
10131        '''
10132         Reserved for future use.
10133        '''
10134        self.rate_limit = rate_limit if rate_limit is not None else None
10135        '''
10136         Rate limit information.
10137        '''
10138        self.remote_identity = remote_identity if remote_identity is not None else None
10139        '''
10140         The updated RemoteIdentity.
10141        '''
10142
10143    def __repr__(self):
10144        return '<sdm.RemoteIdentityUpdateResponse ' + \
10145            'meta: ' + repr(self.meta) + ' ' +\
10146            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10147            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10148            '>'
10149
10150    def to_dict(self):
10151        return {
10152            'meta': self.meta,
10153            'rate_limit': self.rate_limit,
10154            'remote_identity': self.remote_identity,
10155        }
10156
10157    @classmethod
10158    def from_dict(cls, d):
10159        return cls(
10160            meta=d.get('meta'),
10161            rate_limit=d.get('rate_limit'),
10162            remote_identity=d.get('remote_identity'),
10163        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10124    def __init__(
10125        self,
10126        meta=None,
10127        rate_limit=None,
10128        remote_identity=None,
10129    ):
10130        self.meta = meta if meta is not None else None
10131        '''
10132         Reserved for future use.
10133        '''
10134        self.rate_limit = rate_limit if rate_limit is not None else None
10135        '''
10136         Rate limit information.
10137        '''
10138        self.remote_identity = remote_identity if remote_identity is not None else None
10139        '''
10140         The updated RemoteIdentity.
10141        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10150    def to_dict(self):
10151        return {
10152            'meta': self.meta,
10153            'rate_limit': self.rate_limit,
10154            'remote_identity': self.remote_identity,
10155        }
@classmethod
def from_dict(cls, d)
10157    @classmethod
10158    def from_dict(cls, d):
10159        return cls(
10160            meta=d.get('meta'),
10161            rate_limit=d.get('rate_limit'),
10162            remote_identity=d.get('remote_identity'),
10163        )
class ResourceCreateResponse:
10166class ResourceCreateResponse:
10167    '''
10168         ResourceCreateResponse reports how the Resources were created in the system.
10169    '''
10170    __slots__ = [
10171        'meta',
10172        'rate_limit',
10173        'resource',
10174    ]
10175
10176    def __init__(
10177        self,
10178        meta=None,
10179        rate_limit=None,
10180        resource=None,
10181    ):
10182        self.meta = meta if meta is not None else None
10183        '''
10184         Reserved for future use.
10185        '''
10186        self.rate_limit = rate_limit if rate_limit is not None else None
10187        '''
10188         Rate limit information.
10189        '''
10190        self.resource = resource if resource is not None else None
10191        '''
10192         The created Resource.
10193        '''
10194
10195    def __repr__(self):
10196        return '<sdm.ResourceCreateResponse ' + \
10197            'meta: ' + repr(self.meta) + ' ' +\
10198            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10199            'resource: ' + repr(self.resource) + ' ' +\
10200            '>'
10201
10202    def to_dict(self):
10203        return {
10204            'meta': self.meta,
10205            'rate_limit': self.rate_limit,
10206            'resource': self.resource,
10207        }
10208
10209    @classmethod
10210    def from_dict(cls, d):
10211        return cls(
10212            meta=d.get('meta'),
10213            rate_limit=d.get('rate_limit'),
10214            resource=d.get('resource'),
10215        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10176    def __init__(
10177        self,
10178        meta=None,
10179        rate_limit=None,
10180        resource=None,
10181    ):
10182        self.meta = meta if meta is not None else None
10183        '''
10184         Reserved for future use.
10185        '''
10186        self.rate_limit = rate_limit if rate_limit is not None else None
10187        '''
10188         Rate limit information.
10189        '''
10190        self.resource = resource if resource is not None else None
10191        '''
10192         The created Resource.
10193        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10202    def to_dict(self):
10203        return {
10204            'meta': self.meta,
10205            'rate_limit': self.rate_limit,
10206            'resource': self.resource,
10207        }
@classmethod
def from_dict(cls, d)
10209    @classmethod
10210    def from_dict(cls, d):
10211        return cls(
10212            meta=d.get('meta'),
10213            rate_limit=d.get('rate_limit'),
10214            resource=d.get('resource'),
10215        )
class ResourceDeleteResponse:
10218class ResourceDeleteResponse:
10219    '''
10220         ResourceDeleteResponse returns information about a Resource that was deleted.
10221    '''
10222    __slots__ = [
10223        'meta',
10224        'rate_limit',
10225    ]
10226
10227    def __init__(
10228        self,
10229        meta=None,
10230        rate_limit=None,
10231    ):
10232        self.meta = meta if meta is not None else None
10233        '''
10234         Reserved for future use.
10235        '''
10236        self.rate_limit = rate_limit if rate_limit is not None else None
10237        '''
10238         Rate limit information.
10239        '''
10240
10241    def __repr__(self):
10242        return '<sdm.ResourceDeleteResponse ' + \
10243            'meta: ' + repr(self.meta) + ' ' +\
10244            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10245            '>'
10246
10247    def to_dict(self):
10248        return {
10249            'meta': self.meta,
10250            'rate_limit': self.rate_limit,
10251        }
10252
10253    @classmethod
10254    def from_dict(cls, d):
10255        return cls(
10256            meta=d.get('meta'),
10257            rate_limit=d.get('rate_limit'),
10258        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10227    def __init__(
10228        self,
10229        meta=None,
10230        rate_limit=None,
10231    ):
10232        self.meta = meta if meta is not None else None
10233        '''
10234         Reserved for future use.
10235        '''
10236        self.rate_limit = rate_limit if rate_limit is not None else None
10237        '''
10238         Rate limit information.
10239        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10247    def to_dict(self):
10248        return {
10249            'meta': self.meta,
10250            'rate_limit': self.rate_limit,
10251        }
@classmethod
def from_dict(cls, d)
10253    @classmethod
10254    def from_dict(cls, d):
10255        return cls(
10256            meta=d.get('meta'),
10257            rate_limit=d.get('rate_limit'),
10258        )
class ResourceGetResponse:
10261class ResourceGetResponse:
10262    '''
10263         ResourceGetResponse returns a requested Resource.
10264    '''
10265    __slots__ = [
10266        'meta',
10267        'rate_limit',
10268        'resource',
10269    ]
10270
10271    def __init__(
10272        self,
10273        meta=None,
10274        rate_limit=None,
10275        resource=None,
10276    ):
10277        self.meta = meta if meta is not None else None
10278        '''
10279         Reserved for future use.
10280        '''
10281        self.rate_limit = rate_limit if rate_limit is not None else None
10282        '''
10283         Rate limit information.
10284        '''
10285        self.resource = resource if resource is not None else None
10286        '''
10287         The requested Resource.
10288        '''
10289
10290    def __repr__(self):
10291        return '<sdm.ResourceGetResponse ' + \
10292            'meta: ' + repr(self.meta) + ' ' +\
10293            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10294            'resource: ' + repr(self.resource) + ' ' +\
10295            '>'
10296
10297    def to_dict(self):
10298        return {
10299            'meta': self.meta,
10300            'rate_limit': self.rate_limit,
10301            'resource': self.resource,
10302        }
10303
10304    @classmethod
10305    def from_dict(cls, d):
10306        return cls(
10307            meta=d.get('meta'),
10308            rate_limit=d.get('rate_limit'),
10309            resource=d.get('resource'),
10310        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10271    def __init__(
10272        self,
10273        meta=None,
10274        rate_limit=None,
10275        resource=None,
10276    ):
10277        self.meta = meta if meta is not None else None
10278        '''
10279         Reserved for future use.
10280        '''
10281        self.rate_limit = rate_limit if rate_limit is not None else None
10282        '''
10283         Rate limit information.
10284        '''
10285        self.resource = resource if resource is not None else None
10286        '''
10287         The requested Resource.
10288        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10297    def to_dict(self):
10298        return {
10299            'meta': self.meta,
10300            'rate_limit': self.rate_limit,
10301            'resource': self.resource,
10302        }
@classmethod
def from_dict(cls, d)
10304    @classmethod
10305    def from_dict(cls, d):
10306        return cls(
10307            meta=d.get('meta'),
10308            rate_limit=d.get('rate_limit'),
10309            resource=d.get('resource'),
10310        )
class ResourceUpdateResponse:
10313class ResourceUpdateResponse:
10314    '''
10315         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10316     a ResourceUpdateRequest.
10317    '''
10318    __slots__ = [
10319        'meta',
10320        'rate_limit',
10321        'resource',
10322    ]
10323
10324    def __init__(
10325        self,
10326        meta=None,
10327        rate_limit=None,
10328        resource=None,
10329    ):
10330        self.meta = meta if meta is not None else None
10331        '''
10332         Reserved for future use.
10333        '''
10334        self.rate_limit = rate_limit if rate_limit is not None else None
10335        '''
10336         Rate limit information.
10337        '''
10338        self.resource = resource if resource is not None else None
10339        '''
10340         The updated Resource.
10341        '''
10342
10343    def __repr__(self):
10344        return '<sdm.ResourceUpdateResponse ' + \
10345            'meta: ' + repr(self.meta) + ' ' +\
10346            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10347            'resource: ' + repr(self.resource) + ' ' +\
10348            '>'
10349
10350    def to_dict(self):
10351        return {
10352            'meta': self.meta,
10353            'rate_limit': self.rate_limit,
10354            'resource': self.resource,
10355        }
10356
10357    @classmethod
10358    def from_dict(cls, d):
10359        return cls(
10360            meta=d.get('meta'),
10361            rate_limit=d.get('rate_limit'),
10362            resource=d.get('resource'),
10363        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10324    def __init__(
10325        self,
10326        meta=None,
10327        rate_limit=None,
10328        resource=None,
10329    ):
10330        self.meta = meta if meta is not None else None
10331        '''
10332         Reserved for future use.
10333        '''
10334        self.rate_limit = rate_limit if rate_limit is not None else None
10335        '''
10336         Rate limit information.
10337        '''
10338        self.resource = resource if resource is not None else None
10339        '''
10340         The updated Resource.
10341        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10350    def to_dict(self):
10351        return {
10352            'meta': self.meta,
10353            'rate_limit': self.rate_limit,
10354            'resource': self.resource,
10355        }
@classmethod
def from_dict(cls, d)
10357    @classmethod
10358    def from_dict(cls, d):
10359        return cls(
10360            meta=d.get('meta'),
10361            rate_limit=d.get('rate_limit'),
10362            resource=d.get('resource'),
10363        )
class Role:
10366class Role:
10367    '''
10368         A Role has a list of access rules which determine which Resources the members
10369     of the Role have access to. An Account can be a member of multiple Roles via
10370     AccountAttachments.
10371    '''
10372    __slots__ = [
10373        'access_rules',
10374        'id',
10375        'name',
10376        'tags',
10377    ]
10378
10379    def __init__(
10380        self,
10381        access_rules=None,
10382        id=None,
10383        name=None,
10384        tags=None,
10385    ):
10386        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10387        )
10388        '''
10389         AccessRules is a list of access rules defining the resources this Role has access to.
10390        '''
10391        self.id = id if id is not None else ''
10392        '''
10393         Unique identifier of the Role.
10394        '''
10395        self.name = name if name is not None else ''
10396        '''
10397         Unique human-readable name of the Role.
10398        '''
10399        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10400        '''
10401         Tags is a map of key, value pairs.
10402        '''
10403
10404    def __repr__(self):
10405        return '<sdm.Role ' + \
10406            'access_rules: ' + repr(self.access_rules) + ' ' +\
10407            'id: ' + repr(self.id) + ' ' +\
10408            'name: ' + repr(self.name) + ' ' +\
10409            'tags: ' + repr(self.tags) + ' ' +\
10410            '>'
10411
10412    def to_dict(self):
10413        return {
10414            'access_rules': self.access_rules,
10415            'id': self.id,
10416            'name': self.name,
10417            'tags': self.tags,
10418        }
10419
10420    @classmethod
10421    def from_dict(cls, d):
10422        return cls(
10423            access_rules=d.get('access_rules'),
10424            id=d.get('id'),
10425            name=d.get('name'),
10426            tags=d.get('tags'),
10427        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, name=None, tags=None)
10379    def __init__(
10380        self,
10381        access_rules=None,
10382        id=None,
10383        name=None,
10384        tags=None,
10385    ):
10386        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10387        )
10388        '''
10389         AccessRules is a list of access rules defining the resources this Role has access to.
10390        '''
10391        self.id = id if id is not None else ''
10392        '''
10393         Unique identifier of the Role.
10394        '''
10395        self.name = name if name is not None else ''
10396        '''
10397         Unique human-readable name of the Role.
10398        '''
10399        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10400        '''
10401         Tags is a map of key, value pairs.
10402        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10412    def to_dict(self):
10413        return {
10414            'access_rules': self.access_rules,
10415            'id': self.id,
10416            'name': self.name,
10417            'tags': self.tags,
10418        }
@classmethod
def from_dict(cls, d)
10420    @classmethod
10421    def from_dict(cls, d):
10422        return cls(
10423            access_rules=d.get('access_rules'),
10424            id=d.get('id'),
10425            name=d.get('name'),
10426            tags=d.get('tags'),
10427        )
class RoleCreateResponse:
10430class RoleCreateResponse:
10431    '''
10432         RoleCreateResponse reports how the Roles were created in the system. It can
10433     communicate partial successes or failures.
10434    '''
10435    __slots__ = [
10436        'meta',
10437        'rate_limit',
10438        'role',
10439    ]
10440
10441    def __init__(
10442        self,
10443        meta=None,
10444        rate_limit=None,
10445        role=None,
10446    ):
10447        self.meta = meta if meta is not None else None
10448        '''
10449         Reserved for future use.
10450        '''
10451        self.rate_limit = rate_limit if rate_limit is not None else None
10452        '''
10453         Rate limit information.
10454        '''
10455        self.role = role if role is not None else None
10456        '''
10457         The created Role.
10458        '''
10459
10460    def __repr__(self):
10461        return '<sdm.RoleCreateResponse ' + \
10462            'meta: ' + repr(self.meta) + ' ' +\
10463            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10464            'role: ' + repr(self.role) + ' ' +\
10465            '>'
10466
10467    def to_dict(self):
10468        return {
10469            'meta': self.meta,
10470            'rate_limit': self.rate_limit,
10471            'role': self.role,
10472        }
10473
10474    @classmethod
10475    def from_dict(cls, d):
10476        return cls(
10477            meta=d.get('meta'),
10478            rate_limit=d.get('rate_limit'),
10479            role=d.get('role'),
10480        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
10441    def __init__(
10442        self,
10443        meta=None,
10444        rate_limit=None,
10445        role=None,
10446    ):
10447        self.meta = meta if meta is not None else None
10448        '''
10449         Reserved for future use.
10450        '''
10451        self.rate_limit = rate_limit if rate_limit is not None else None
10452        '''
10453         Rate limit information.
10454        '''
10455        self.role = role if role is not None else None
10456        '''
10457         The created Role.
10458        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
10467    def to_dict(self):
10468        return {
10469            'meta': self.meta,
10470            'rate_limit': self.rate_limit,
10471            'role': self.role,
10472        }
@classmethod
def from_dict(cls, d)
10474    @classmethod
10475    def from_dict(cls, d):
10476        return cls(
10477            meta=d.get('meta'),
10478            rate_limit=d.get('rate_limit'),
10479            role=d.get('role'),
10480        )
class RoleDeleteResponse:
10483class RoleDeleteResponse:
10484    '''
10485         RoleDeleteResponse returns information about a Role that was deleted.
10486    '''
10487    __slots__ = [
10488        'meta',
10489        'rate_limit',
10490    ]
10491
10492    def __init__(
10493        self,
10494        meta=None,
10495        rate_limit=None,
10496    ):
10497        self.meta = meta if meta is not None else None
10498        '''
10499         Reserved for future use.
10500        '''
10501        self.rate_limit = rate_limit if rate_limit is not None else None
10502        '''
10503         Rate limit information.
10504        '''
10505
10506    def __repr__(self):
10507        return '<sdm.RoleDeleteResponse ' + \
10508            'meta: ' + repr(self.meta) + ' ' +\
10509            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10510            '>'
10511
10512    def to_dict(self):
10513        return {
10514            'meta': self.meta,
10515            'rate_limit': self.rate_limit,
10516        }
10517
10518    @classmethod
10519    def from_dict(cls, d):
10520        return cls(
10521            meta=d.get('meta'),
10522            rate_limit=d.get('rate_limit'),
10523        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
10492    def __init__(
10493        self,
10494        meta=None,
10495        rate_limit=None,
10496    ):
10497        self.meta = meta if meta is not None else None
10498        '''
10499         Reserved for future use.
10500        '''
10501        self.rate_limit = rate_limit if rate_limit is not None else None
10502        '''
10503         Rate limit information.
10504        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10512    def to_dict(self):
10513        return {
10514            'meta': self.meta,
10515            'rate_limit': self.rate_limit,
10516        }
@classmethod
def from_dict(cls, d)
10518    @classmethod
10519    def from_dict(cls, d):
10520        return cls(
10521            meta=d.get('meta'),
10522            rate_limit=d.get('rate_limit'),
10523        )
class RoleGetResponse:
10526class RoleGetResponse:
10527    '''
10528         RoleGetResponse returns a requested Role.
10529    '''
10530    __slots__ = [
10531        'meta',
10532        'rate_limit',
10533        'role',
10534    ]
10535
10536    def __init__(
10537        self,
10538        meta=None,
10539        rate_limit=None,
10540        role=None,
10541    ):
10542        self.meta = meta if meta is not None else None
10543        '''
10544         Reserved for future use.
10545        '''
10546        self.rate_limit = rate_limit if rate_limit is not None else None
10547        '''
10548         Rate limit information.
10549        '''
10550        self.role = role if role is not None else None
10551        '''
10552         The requested Role.
10553        '''
10554
10555    def __repr__(self):
10556        return '<sdm.RoleGetResponse ' + \
10557            'meta: ' + repr(self.meta) + ' ' +\
10558            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10559            'role: ' + repr(self.role) + ' ' +\
10560            '>'
10561
10562    def to_dict(self):
10563        return {
10564            'meta': self.meta,
10565            'rate_limit': self.rate_limit,
10566            'role': self.role,
10567        }
10568
10569    @classmethod
10570    def from_dict(cls, d):
10571        return cls(
10572            meta=d.get('meta'),
10573            rate_limit=d.get('rate_limit'),
10574            role=d.get('role'),
10575        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10536    def __init__(
10537        self,
10538        meta=None,
10539        rate_limit=None,
10540        role=None,
10541    ):
10542        self.meta = meta if meta is not None else None
10543        '''
10544         Reserved for future use.
10545        '''
10546        self.rate_limit = rate_limit if rate_limit is not None else None
10547        '''
10548         Rate limit information.
10549        '''
10550        self.role = role if role is not None else None
10551        '''
10552         The requested Role.
10553        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10562    def to_dict(self):
10563        return {
10564            'meta': self.meta,
10565            'rate_limit': self.rate_limit,
10566            'role': self.role,
10567        }
@classmethod
def from_dict(cls, d)
10569    @classmethod
10570    def from_dict(cls, d):
10571        return cls(
10572            meta=d.get('meta'),
10573            rate_limit=d.get('rate_limit'),
10574            role=d.get('role'),
10575        )
class RoleUpdateResponse:
10578class RoleUpdateResponse:
10579    '''
10580         RoleUpdateResponse returns the fields of a Role after it has been updated by
10581     a RoleUpdateRequest.
10582    '''
10583    __slots__ = [
10584        'meta',
10585        'rate_limit',
10586        'role',
10587    ]
10588
10589    def __init__(
10590        self,
10591        meta=None,
10592        rate_limit=None,
10593        role=None,
10594    ):
10595        self.meta = meta if meta is not None else None
10596        '''
10597         Reserved for future use.
10598        '''
10599        self.rate_limit = rate_limit if rate_limit is not None else None
10600        '''
10601         Rate limit information.
10602        '''
10603        self.role = role if role is not None else None
10604        '''
10605         The updated Role.
10606        '''
10607
10608    def __repr__(self):
10609        return '<sdm.RoleUpdateResponse ' + \
10610            'meta: ' + repr(self.meta) + ' ' +\
10611            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10612            'role: ' + repr(self.role) + ' ' +\
10613            '>'
10614
10615    def to_dict(self):
10616        return {
10617            'meta': self.meta,
10618            'rate_limit': self.rate_limit,
10619            'role': self.role,
10620        }
10621
10622    @classmethod
10623    def from_dict(cls, d):
10624        return cls(
10625            meta=d.get('meta'),
10626            rate_limit=d.get('rate_limit'),
10627            role=d.get('role'),
10628        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10589    def __init__(
10590        self,
10591        meta=None,
10592        rate_limit=None,
10593        role=None,
10594    ):
10595        self.meta = meta if meta is not None else None
10596        '''
10597         Reserved for future use.
10598        '''
10599        self.rate_limit = rate_limit if rate_limit is not None else None
10600        '''
10601         Rate limit information.
10602        '''
10603        self.role = role if role is not None else None
10604        '''
10605         The updated Role.
10606        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10615    def to_dict(self):
10616        return {
10617            'meta': self.meta,
10618            'rate_limit': self.rate_limit,
10619            'role': self.role,
10620        }
@classmethod
def from_dict(cls, d)
10622    @classmethod
10623    def from_dict(cls, d):
10624        return cls(
10625            meta=d.get('meta'),
10626            rate_limit=d.get('rate_limit'),
10627            role=d.get('role'),
10628        )
class SQLServer:
10631class SQLServer:
10632    __slots__ = [
10633        'bind_interface',
10634        'database',
10635        'egress_filter',
10636        'healthy',
10637        'hostname',
10638        'id',
10639        'name',
10640        'override_database',
10641        'password',
10642        'port',
10643        'port_override',
10644        'schema',
10645        'secret_store_id',
10646        'tags',
10647        'username',
10648    ]
10649
10650    def __init__(
10651        self,
10652        bind_interface=None,
10653        database=None,
10654        egress_filter=None,
10655        healthy=None,
10656        hostname=None,
10657        id=None,
10658        name=None,
10659        override_database=None,
10660        password=None,
10661        port=None,
10662        port_override=None,
10663        schema=None,
10664        secret_store_id=None,
10665        tags=None,
10666        username=None,
10667    ):
10668        self.bind_interface = bind_interface if bind_interface is not None else ''
10669        '''
10670         Bind interface
10671        '''
10672        self.database = database if database is not None else ''
10673        self.egress_filter = egress_filter if egress_filter is not None else ''
10674        '''
10675         A filter applied to the routing logic to pin datasource to nodes.
10676        '''
10677        self.healthy = healthy if healthy is not None else False
10678        '''
10679         True if the datasource is reachable and the credentials are valid.
10680        '''
10681        self.hostname = hostname if hostname is not None else ''
10682        self.id = id if id is not None else ''
10683        '''
10684         Unique identifier of the Resource.
10685        '''
10686        self.name = name if name is not None else ''
10687        '''
10688         Unique human-readable name of the Resource.
10689        '''
10690        self.override_database = override_database if override_database is not None else False
10691        self.password = password if password is not None else ''
10692        self.port = port if port is not None else 0
10693        self.port_override = port_override if port_override is not None else 0
10694        self.schema = schema if schema is not None else ''
10695        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10696        '''
10697         ID of the secret store containing credentials for this resource, if any.
10698        '''
10699        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10700        '''
10701         Tags is a map of key, value pairs.
10702        '''
10703        self.username = username if username is not None else ''
10704
10705    def __repr__(self):
10706        return '<sdm.SQLServer ' + \
10707            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10708            'database: ' + repr(self.database) + ' ' +\
10709            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10710            'healthy: ' + repr(self.healthy) + ' ' +\
10711            'hostname: ' + repr(self.hostname) + ' ' +\
10712            'id: ' + repr(self.id) + ' ' +\
10713            'name: ' + repr(self.name) + ' ' +\
10714            'override_database: ' + repr(self.override_database) + ' ' +\
10715            'password: ' + repr(self.password) + ' ' +\
10716            'port: ' + repr(self.port) + ' ' +\
10717            'port_override: ' + repr(self.port_override) + ' ' +\
10718            'schema: ' + repr(self.schema) + ' ' +\
10719            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10720            'tags: ' + repr(self.tags) + ' ' +\
10721            'username: ' + repr(self.username) + ' ' +\
10722            '>'
10723
10724    def to_dict(self):
10725        return {
10726            'bind_interface': self.bind_interface,
10727            'database': self.database,
10728            'egress_filter': self.egress_filter,
10729            'healthy': self.healthy,
10730            'hostname': self.hostname,
10731            'id': self.id,
10732            'name': self.name,
10733            'override_database': self.override_database,
10734            'password': self.password,
10735            'port': self.port,
10736            'port_override': self.port_override,
10737            'schema': self.schema,
10738            'secret_store_id': self.secret_store_id,
10739            'tags': self.tags,
10740            'username': self.username,
10741        }
10742
10743    @classmethod
10744    def from_dict(cls, d):
10745        return cls(
10746            bind_interface=d.get('bind_interface'),
10747            database=d.get('database'),
10748            egress_filter=d.get('egress_filter'),
10749            healthy=d.get('healthy'),
10750            hostname=d.get('hostname'),
10751            id=d.get('id'),
10752            name=d.get('name'),
10753            override_database=d.get('override_database'),
10754            password=d.get('password'),
10755            port=d.get('port'),
10756            port_override=d.get('port_override'),
10757            schema=d.get('schema'),
10758            secret_store_id=d.get('secret_store_id'),
10759            tags=d.get('tags'),
10760            username=d.get('username'),
10761        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10650    def __init__(
10651        self,
10652        bind_interface=None,
10653        database=None,
10654        egress_filter=None,
10655        healthy=None,
10656        hostname=None,
10657        id=None,
10658        name=None,
10659        override_database=None,
10660        password=None,
10661        port=None,
10662        port_override=None,
10663        schema=None,
10664        secret_store_id=None,
10665        tags=None,
10666        username=None,
10667    ):
10668        self.bind_interface = bind_interface if bind_interface is not None else ''
10669        '''
10670         Bind interface
10671        '''
10672        self.database = database if database is not None else ''
10673        self.egress_filter = egress_filter if egress_filter is not None else ''
10674        '''
10675         A filter applied to the routing logic to pin datasource to nodes.
10676        '''
10677        self.healthy = healthy if healthy is not None else False
10678        '''
10679         True if the datasource is reachable and the credentials are valid.
10680        '''
10681        self.hostname = hostname if hostname is not None else ''
10682        self.id = id if id is not None else ''
10683        '''
10684         Unique identifier of the Resource.
10685        '''
10686        self.name = name if name is not None else ''
10687        '''
10688         Unique human-readable name of the Resource.
10689        '''
10690        self.override_database = override_database if override_database is not None else False
10691        self.password = password if password is not None else ''
10692        self.port = port if port is not None else 0
10693        self.port_override = port_override if port_override is not None else 0
10694        self.schema = schema if schema is not None else ''
10695        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10696        '''
10697         ID of the secret store containing credentials for this resource, if any.
10698        '''
10699        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10700        '''
10701         Tags is a map of key, value pairs.
10702        '''
10703        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10724    def to_dict(self):
10725        return {
10726            'bind_interface': self.bind_interface,
10727            'database': self.database,
10728            'egress_filter': self.egress_filter,
10729            'healthy': self.healthy,
10730            'hostname': self.hostname,
10731            'id': self.id,
10732            'name': self.name,
10733            'override_database': self.override_database,
10734            'password': self.password,
10735            'port': self.port,
10736            'port_override': self.port_override,
10737            'schema': self.schema,
10738            'secret_store_id': self.secret_store_id,
10739            'tags': self.tags,
10740            'username': self.username,
10741        }
@classmethod
def from_dict(cls, d)
10743    @classmethod
10744    def from_dict(cls, d):
10745        return cls(
10746            bind_interface=d.get('bind_interface'),
10747            database=d.get('database'),
10748            egress_filter=d.get('egress_filter'),
10749            healthy=d.get('healthy'),
10750            hostname=d.get('hostname'),
10751            id=d.get('id'),
10752            name=d.get('name'),
10753            override_database=d.get('override_database'),
10754            password=d.get('password'),
10755            port=d.get('port'),
10756            port_override=d.get('port_override'),
10757            schema=d.get('schema'),
10758            secret_store_id=d.get('secret_store_id'),
10759            tags=d.get('tags'),
10760            username=d.get('username'),
10761        )
class SSH:
10764class SSH:
10765    __slots__ = [
10766        'allow_deprecated_key_exchanges',
10767        'bind_interface',
10768        'egress_filter',
10769        'healthy',
10770        'hostname',
10771        'id',
10772        'key_type',
10773        'name',
10774        'port',
10775        'port_forwarding',
10776        'port_override',
10777        'public_key',
10778        'secret_store_id',
10779        'tags',
10780        'username',
10781    ]
10782
10783    def __init__(
10784        self,
10785        allow_deprecated_key_exchanges=None,
10786        bind_interface=None,
10787        egress_filter=None,
10788        healthy=None,
10789        hostname=None,
10790        id=None,
10791        key_type=None,
10792        name=None,
10793        port=None,
10794        port_forwarding=None,
10795        port_override=None,
10796        public_key=None,
10797        secret_store_id=None,
10798        tags=None,
10799        username=None,
10800    ):
10801        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10802        self.bind_interface = bind_interface if bind_interface is not None else ''
10803        '''
10804         Bind interface
10805        '''
10806        self.egress_filter = egress_filter if egress_filter is not None else ''
10807        '''
10808         A filter applied to the routing logic to pin datasource to nodes.
10809        '''
10810        self.healthy = healthy if healthy is not None else False
10811        '''
10812         True if the datasource is reachable and the credentials are valid.
10813        '''
10814        self.hostname = hostname if hostname is not None else ''
10815        self.id = id if id is not None else ''
10816        '''
10817         Unique identifier of the Resource.
10818        '''
10819        self.key_type = key_type if key_type is not None else ''
10820        self.name = name if name is not None else ''
10821        '''
10822         Unique human-readable name of the Resource.
10823        '''
10824        self.port = port if port is not None else 0
10825        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10826        self.port_override = port_override if port_override is not None else 0
10827        self.public_key = public_key if public_key is not None else ''
10828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10829        '''
10830         ID of the secret store containing credentials for this resource, if any.
10831        '''
10832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10833        '''
10834         Tags is a map of key, value pairs.
10835        '''
10836        self.username = username if username is not None else ''
10837
10838    def __repr__(self):
10839        return '<sdm.SSH ' + \
10840            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10841            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10842            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10843            'healthy: ' + repr(self.healthy) + ' ' +\
10844            'hostname: ' + repr(self.hostname) + ' ' +\
10845            'id: ' + repr(self.id) + ' ' +\
10846            'key_type: ' + repr(self.key_type) + ' ' +\
10847            'name: ' + repr(self.name) + ' ' +\
10848            'port: ' + repr(self.port) + ' ' +\
10849            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10850            'port_override: ' + repr(self.port_override) + ' ' +\
10851            'public_key: ' + repr(self.public_key) + ' ' +\
10852            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10853            'tags: ' + repr(self.tags) + ' ' +\
10854            'username: ' + repr(self.username) + ' ' +\
10855            '>'
10856
10857    def to_dict(self):
10858        return {
10859            'allow_deprecated_key_exchanges':
10860            self.allow_deprecated_key_exchanges,
10861            'bind_interface': self.bind_interface,
10862            'egress_filter': self.egress_filter,
10863            'healthy': self.healthy,
10864            'hostname': self.hostname,
10865            'id': self.id,
10866            'key_type': self.key_type,
10867            'name': self.name,
10868            'port': self.port,
10869            'port_forwarding': self.port_forwarding,
10870            'port_override': self.port_override,
10871            'public_key': self.public_key,
10872            'secret_store_id': self.secret_store_id,
10873            'tags': self.tags,
10874            'username': self.username,
10875        }
10876
10877    @classmethod
10878    def from_dict(cls, d):
10879        return cls(
10880            allow_deprecated_key_exchanges=d.get(
10881                'allow_deprecated_key_exchanges'),
10882            bind_interface=d.get('bind_interface'),
10883            egress_filter=d.get('egress_filter'),
10884            healthy=d.get('healthy'),
10885            hostname=d.get('hostname'),
10886            id=d.get('id'),
10887            key_type=d.get('key_type'),
10888            name=d.get('name'),
10889            port=d.get('port'),
10890            port_forwarding=d.get('port_forwarding'),
10891            port_override=d.get('port_override'),
10892            public_key=d.get('public_key'),
10893            secret_store_id=d.get('secret_store_id'),
10894            tags=d.get('tags'),
10895            username=d.get('username'),
10896        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10783    def __init__(
10784        self,
10785        allow_deprecated_key_exchanges=None,
10786        bind_interface=None,
10787        egress_filter=None,
10788        healthy=None,
10789        hostname=None,
10790        id=None,
10791        key_type=None,
10792        name=None,
10793        port=None,
10794        port_forwarding=None,
10795        port_override=None,
10796        public_key=None,
10797        secret_store_id=None,
10798        tags=None,
10799        username=None,
10800    ):
10801        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10802        self.bind_interface = bind_interface if bind_interface is not None else ''
10803        '''
10804         Bind interface
10805        '''
10806        self.egress_filter = egress_filter if egress_filter is not None else ''
10807        '''
10808         A filter applied to the routing logic to pin datasource to nodes.
10809        '''
10810        self.healthy = healthy if healthy is not None else False
10811        '''
10812         True if the datasource is reachable and the credentials are valid.
10813        '''
10814        self.hostname = hostname if hostname is not None else ''
10815        self.id = id if id is not None else ''
10816        '''
10817         Unique identifier of the Resource.
10818        '''
10819        self.key_type = key_type if key_type is not None else ''
10820        self.name = name if name is not None else ''
10821        '''
10822         Unique human-readable name of the Resource.
10823        '''
10824        self.port = port if port is not None else 0
10825        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10826        self.port_override = port_override if port_override is not None else 0
10827        self.public_key = public_key if public_key is not None else ''
10828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10829        '''
10830         ID of the secret store containing credentials for this resource, if any.
10831        '''
10832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10833        '''
10834         Tags is a map of key, value pairs.
10835        '''
10836        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10857    def to_dict(self):
10858        return {
10859            'allow_deprecated_key_exchanges':
10860            self.allow_deprecated_key_exchanges,
10861            'bind_interface': self.bind_interface,
10862            'egress_filter': self.egress_filter,
10863            'healthy': self.healthy,
10864            'hostname': self.hostname,
10865            'id': self.id,
10866            'key_type': self.key_type,
10867            'name': self.name,
10868            'port': self.port,
10869            'port_forwarding': self.port_forwarding,
10870            'port_override': self.port_override,
10871            'public_key': self.public_key,
10872            'secret_store_id': self.secret_store_id,
10873            'tags': self.tags,
10874            'username': self.username,
10875        }
@classmethod
def from_dict(cls, d)
10877    @classmethod
10878    def from_dict(cls, d):
10879        return cls(
10880            allow_deprecated_key_exchanges=d.get(
10881                'allow_deprecated_key_exchanges'),
10882            bind_interface=d.get('bind_interface'),
10883            egress_filter=d.get('egress_filter'),
10884            healthy=d.get('healthy'),
10885            hostname=d.get('hostname'),
10886            id=d.get('id'),
10887            key_type=d.get('key_type'),
10888            name=d.get('name'),
10889            port=d.get('port'),
10890            port_forwarding=d.get('port_forwarding'),
10891            port_override=d.get('port_override'),
10892            public_key=d.get('public_key'),
10893            secret_store_id=d.get('secret_store_id'),
10894            tags=d.get('tags'),
10895            username=d.get('username'),
10896        )
class SSHCert:
10899class SSHCert:
10900    __slots__ = [
10901        'allow_deprecated_key_exchanges',
10902        'bind_interface',
10903        'egress_filter',
10904        'healthy',
10905        'hostname',
10906        'id',
10907        'key_type',
10908        'name',
10909        'port',
10910        'port_forwarding',
10911        'port_override',
10912        'remote_identity_group_id',
10913        'remote_identity_healthcheck_username',
10914        'secret_store_id',
10915        'tags',
10916        'username',
10917    ]
10918
10919    def __init__(
10920        self,
10921        allow_deprecated_key_exchanges=None,
10922        bind_interface=None,
10923        egress_filter=None,
10924        healthy=None,
10925        hostname=None,
10926        id=None,
10927        key_type=None,
10928        name=None,
10929        port=None,
10930        port_forwarding=None,
10931        port_override=None,
10932        remote_identity_group_id=None,
10933        remote_identity_healthcheck_username=None,
10934        secret_store_id=None,
10935        tags=None,
10936        username=None,
10937    ):
10938        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10939        self.bind_interface = bind_interface if bind_interface is not None else ''
10940        '''
10941         Bind interface
10942        '''
10943        self.egress_filter = egress_filter if egress_filter is not None else ''
10944        '''
10945         A filter applied to the routing logic to pin datasource to nodes.
10946        '''
10947        self.healthy = healthy if healthy is not None else False
10948        '''
10949         True if the datasource is reachable and the credentials are valid.
10950        '''
10951        self.hostname = hostname if hostname is not None else ''
10952        self.id = id if id is not None else ''
10953        '''
10954         Unique identifier of the Resource.
10955        '''
10956        self.key_type = key_type if key_type is not None else ''
10957        self.name = name if name is not None else ''
10958        '''
10959         Unique human-readable name of the Resource.
10960        '''
10961        self.port = port if port is not None else 0
10962        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10963        self.port_override = port_override if port_override is not None else 0
10964        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10965        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10966        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10967        '''
10968         ID of the secret store containing credentials for this resource, if any.
10969        '''
10970        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10971        '''
10972         Tags is a map of key, value pairs.
10973        '''
10974        self.username = username if username is not None else ''
10975
10976    def __repr__(self):
10977        return '<sdm.SSHCert ' + \
10978            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10979            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10980            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10981            'healthy: ' + repr(self.healthy) + ' ' +\
10982            'hostname: ' + repr(self.hostname) + ' ' +\
10983            'id: ' + repr(self.id) + ' ' +\
10984            'key_type: ' + repr(self.key_type) + ' ' +\
10985            'name: ' + repr(self.name) + ' ' +\
10986            'port: ' + repr(self.port) + ' ' +\
10987            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10988            'port_override: ' + repr(self.port_override) + ' ' +\
10989            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10990            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10991            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10992            'tags: ' + repr(self.tags) + ' ' +\
10993            'username: ' + repr(self.username) + ' ' +\
10994            '>'
10995
10996    def to_dict(self):
10997        return {
10998            'allow_deprecated_key_exchanges':
10999            self.allow_deprecated_key_exchanges,
11000            'bind_interface': self.bind_interface,
11001            'egress_filter': self.egress_filter,
11002            'healthy': self.healthy,
11003            'hostname': self.hostname,
11004            'id': self.id,
11005            'key_type': self.key_type,
11006            'name': self.name,
11007            'port': self.port,
11008            'port_forwarding': self.port_forwarding,
11009            'port_override': self.port_override,
11010            'remote_identity_group_id': self.remote_identity_group_id,
11011            'remote_identity_healthcheck_username':
11012            self.remote_identity_healthcheck_username,
11013            'secret_store_id': self.secret_store_id,
11014            'tags': self.tags,
11015            'username': self.username,
11016        }
11017
11018    @classmethod
11019    def from_dict(cls, d):
11020        return cls(
11021            allow_deprecated_key_exchanges=d.get(
11022                'allow_deprecated_key_exchanges'),
11023            bind_interface=d.get('bind_interface'),
11024            egress_filter=d.get('egress_filter'),
11025            healthy=d.get('healthy'),
11026            hostname=d.get('hostname'),
11027            id=d.get('id'),
11028            key_type=d.get('key_type'),
11029            name=d.get('name'),
11030            port=d.get('port'),
11031            port_forwarding=d.get('port_forwarding'),
11032            port_override=d.get('port_override'),
11033            remote_identity_group_id=d.get('remote_identity_group_id'),
11034            remote_identity_healthcheck_username=d.get(
11035                'remote_identity_healthcheck_username'),
11036            secret_store_id=d.get('secret_store_id'),
11037            tags=d.get('tags'),
11038            username=d.get('username'),
11039        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10919    def __init__(
10920        self,
10921        allow_deprecated_key_exchanges=None,
10922        bind_interface=None,
10923        egress_filter=None,
10924        healthy=None,
10925        hostname=None,
10926        id=None,
10927        key_type=None,
10928        name=None,
10929        port=None,
10930        port_forwarding=None,
10931        port_override=None,
10932        remote_identity_group_id=None,
10933        remote_identity_healthcheck_username=None,
10934        secret_store_id=None,
10935        tags=None,
10936        username=None,
10937    ):
10938        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10939        self.bind_interface = bind_interface if bind_interface is not None else ''
10940        '''
10941         Bind interface
10942        '''
10943        self.egress_filter = egress_filter if egress_filter is not None else ''
10944        '''
10945         A filter applied to the routing logic to pin datasource to nodes.
10946        '''
10947        self.healthy = healthy if healthy is not None else False
10948        '''
10949         True if the datasource is reachable and the credentials are valid.
10950        '''
10951        self.hostname = hostname if hostname is not None else ''
10952        self.id = id if id is not None else ''
10953        '''
10954         Unique identifier of the Resource.
10955        '''
10956        self.key_type = key_type if key_type is not None else ''
10957        self.name = name if name is not None else ''
10958        '''
10959         Unique human-readable name of the Resource.
10960        '''
10961        self.port = port if port is not None else 0
10962        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10963        self.port_override = port_override if port_override is not None else 0
10964        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10965        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10966        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10967        '''
10968         ID of the secret store containing credentials for this resource, if any.
10969        '''
10970        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10971        '''
10972         Tags is a map of key, value pairs.
10973        '''
10974        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10996    def to_dict(self):
10997        return {
10998            'allow_deprecated_key_exchanges':
10999            self.allow_deprecated_key_exchanges,
11000            'bind_interface': self.bind_interface,
11001            'egress_filter': self.egress_filter,
11002            'healthy': self.healthy,
11003            'hostname': self.hostname,
11004            'id': self.id,
11005            'key_type': self.key_type,
11006            'name': self.name,
11007            'port': self.port,
11008            'port_forwarding': self.port_forwarding,
11009            'port_override': self.port_override,
11010            'remote_identity_group_id': self.remote_identity_group_id,
11011            'remote_identity_healthcheck_username':
11012            self.remote_identity_healthcheck_username,
11013            'secret_store_id': self.secret_store_id,
11014            'tags': self.tags,
11015            'username': self.username,
11016        }
@classmethod
def from_dict(cls, d)
11018    @classmethod
11019    def from_dict(cls, d):
11020        return cls(
11021            allow_deprecated_key_exchanges=d.get(
11022                'allow_deprecated_key_exchanges'),
11023            bind_interface=d.get('bind_interface'),
11024            egress_filter=d.get('egress_filter'),
11025            healthy=d.get('healthy'),
11026            hostname=d.get('hostname'),
11027            id=d.get('id'),
11028            key_type=d.get('key_type'),
11029            name=d.get('name'),
11030            port=d.get('port'),
11031            port_forwarding=d.get('port_forwarding'),
11032            port_override=d.get('port_override'),
11033            remote_identity_group_id=d.get('remote_identity_group_id'),
11034            remote_identity_healthcheck_username=d.get(
11035                'remote_identity_healthcheck_username'),
11036            secret_store_id=d.get('secret_store_id'),
11037            tags=d.get('tags'),
11038            username=d.get('username'),
11039        )
class SSHCustomerKey:
11042class SSHCustomerKey:
11043    __slots__ = [
11044        'allow_deprecated_key_exchanges',
11045        'bind_interface',
11046        'egress_filter',
11047        'healthy',
11048        'hostname',
11049        'id',
11050        'name',
11051        'port',
11052        'port_forwarding',
11053        'port_override',
11054        'private_key',
11055        'secret_store_id',
11056        'tags',
11057        'username',
11058    ]
11059
11060    def __init__(
11061        self,
11062        allow_deprecated_key_exchanges=None,
11063        bind_interface=None,
11064        egress_filter=None,
11065        healthy=None,
11066        hostname=None,
11067        id=None,
11068        name=None,
11069        port=None,
11070        port_forwarding=None,
11071        port_override=None,
11072        private_key=None,
11073        secret_store_id=None,
11074        tags=None,
11075        username=None,
11076    ):
11077        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11078        self.bind_interface = bind_interface if bind_interface is not None else ''
11079        '''
11080         Bind interface
11081        '''
11082        self.egress_filter = egress_filter if egress_filter is not None else ''
11083        '''
11084         A filter applied to the routing logic to pin datasource to nodes.
11085        '''
11086        self.healthy = healthy if healthy is not None else False
11087        '''
11088         True if the datasource is reachable and the credentials are valid.
11089        '''
11090        self.hostname = hostname if hostname is not None else ''
11091        self.id = id if id is not None else ''
11092        '''
11093         Unique identifier of the Resource.
11094        '''
11095        self.name = name if name is not None else ''
11096        '''
11097         Unique human-readable name of the Resource.
11098        '''
11099        self.port = port if port is not None else 0
11100        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11101        self.port_override = port_override if port_override is not None else 0
11102        self.private_key = private_key if private_key is not None else ''
11103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11104        '''
11105         ID of the secret store containing credentials for this resource, if any.
11106        '''
11107        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11108        '''
11109         Tags is a map of key, value pairs.
11110        '''
11111        self.username = username if username is not None else ''
11112
11113    def __repr__(self):
11114        return '<sdm.SSHCustomerKey ' + \
11115            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11116            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11117            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11118            'healthy: ' + repr(self.healthy) + ' ' +\
11119            'hostname: ' + repr(self.hostname) + ' ' +\
11120            'id: ' + repr(self.id) + ' ' +\
11121            'name: ' + repr(self.name) + ' ' +\
11122            'port: ' + repr(self.port) + ' ' +\
11123            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11124            'port_override: ' + repr(self.port_override) + ' ' +\
11125            'private_key: ' + repr(self.private_key) + ' ' +\
11126            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11127            'tags: ' + repr(self.tags) + ' ' +\
11128            'username: ' + repr(self.username) + ' ' +\
11129            '>'
11130
11131    def to_dict(self):
11132        return {
11133            'allow_deprecated_key_exchanges':
11134            self.allow_deprecated_key_exchanges,
11135            'bind_interface': self.bind_interface,
11136            'egress_filter': self.egress_filter,
11137            'healthy': self.healthy,
11138            'hostname': self.hostname,
11139            'id': self.id,
11140            'name': self.name,
11141            'port': self.port,
11142            'port_forwarding': self.port_forwarding,
11143            'port_override': self.port_override,
11144            'private_key': self.private_key,
11145            'secret_store_id': self.secret_store_id,
11146            'tags': self.tags,
11147            'username': self.username,
11148        }
11149
11150    @classmethod
11151    def from_dict(cls, d):
11152        return cls(
11153            allow_deprecated_key_exchanges=d.get(
11154                'allow_deprecated_key_exchanges'),
11155            bind_interface=d.get('bind_interface'),
11156            egress_filter=d.get('egress_filter'),
11157            healthy=d.get('healthy'),
11158            hostname=d.get('hostname'),
11159            id=d.get('id'),
11160            name=d.get('name'),
11161            port=d.get('port'),
11162            port_forwarding=d.get('port_forwarding'),
11163            port_override=d.get('port_override'),
11164            private_key=d.get('private_key'),
11165            secret_store_id=d.get('secret_store_id'),
11166            tags=d.get('tags'),
11167            username=d.get('username'),
11168        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
11060    def __init__(
11061        self,
11062        allow_deprecated_key_exchanges=None,
11063        bind_interface=None,
11064        egress_filter=None,
11065        healthy=None,
11066        hostname=None,
11067        id=None,
11068        name=None,
11069        port=None,
11070        port_forwarding=None,
11071        port_override=None,
11072        private_key=None,
11073        secret_store_id=None,
11074        tags=None,
11075        username=None,
11076    ):
11077        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11078        self.bind_interface = bind_interface if bind_interface is not None else ''
11079        '''
11080         Bind interface
11081        '''
11082        self.egress_filter = egress_filter if egress_filter is not None else ''
11083        '''
11084         A filter applied to the routing logic to pin datasource to nodes.
11085        '''
11086        self.healthy = healthy if healthy is not None else False
11087        '''
11088         True if the datasource is reachable and the credentials are valid.
11089        '''
11090        self.hostname = hostname if hostname is not None else ''
11091        self.id = id if id is not None else ''
11092        '''
11093         Unique identifier of the Resource.
11094        '''
11095        self.name = name if name is not None else ''
11096        '''
11097         Unique human-readable name of the Resource.
11098        '''
11099        self.port = port if port is not None else 0
11100        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11101        self.port_override = port_override if port_override is not None else 0
11102        self.private_key = private_key if private_key is not None else ''
11103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11104        '''
11105         ID of the secret store containing credentials for this resource, if any.
11106        '''
11107        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11108        '''
11109         Tags is a map of key, value pairs.
11110        '''
11111        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11131    def to_dict(self):
11132        return {
11133            'allow_deprecated_key_exchanges':
11134            self.allow_deprecated_key_exchanges,
11135            'bind_interface': self.bind_interface,
11136            'egress_filter': self.egress_filter,
11137            'healthy': self.healthy,
11138            'hostname': self.hostname,
11139            'id': self.id,
11140            'name': self.name,
11141            'port': self.port,
11142            'port_forwarding': self.port_forwarding,
11143            'port_override': self.port_override,
11144            'private_key': self.private_key,
11145            'secret_store_id': self.secret_store_id,
11146            'tags': self.tags,
11147            'username': self.username,
11148        }
@classmethod
def from_dict(cls, d)
11150    @classmethod
11151    def from_dict(cls, d):
11152        return cls(
11153            allow_deprecated_key_exchanges=d.get(
11154                'allow_deprecated_key_exchanges'),
11155            bind_interface=d.get('bind_interface'),
11156            egress_filter=d.get('egress_filter'),
11157            healthy=d.get('healthy'),
11158            hostname=d.get('hostname'),
11159            id=d.get('id'),
11160            name=d.get('name'),
11161            port=d.get('port'),
11162            port_forwarding=d.get('port_forwarding'),
11163            port_override=d.get('port_override'),
11164            private_key=d.get('private_key'),
11165            secret_store_id=d.get('secret_store_id'),
11166            tags=d.get('tags'),
11167            username=d.get('username'),
11168        )
class SecretStoreCreateResponse:
11171class SecretStoreCreateResponse:
11172    '''
11173         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11174    '''
11175    __slots__ = [
11176        'meta',
11177        'rate_limit',
11178        'secret_store',
11179    ]
11180
11181    def __init__(
11182        self,
11183        meta=None,
11184        rate_limit=None,
11185        secret_store=None,
11186    ):
11187        self.meta = meta if meta is not None else None
11188        '''
11189         Reserved for future use.
11190        '''
11191        self.rate_limit = rate_limit if rate_limit is not None else None
11192        '''
11193         Rate limit information.
11194        '''
11195        self.secret_store = secret_store if secret_store is not None else None
11196        '''
11197         The created SecretStore.
11198        '''
11199
11200    def __repr__(self):
11201        return '<sdm.SecretStoreCreateResponse ' + \
11202            'meta: ' + repr(self.meta) + ' ' +\
11203            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11204            'secret_store: ' + repr(self.secret_store) + ' ' +\
11205            '>'
11206
11207    def to_dict(self):
11208        return {
11209            'meta': self.meta,
11210            'rate_limit': self.rate_limit,
11211            'secret_store': self.secret_store,
11212        }
11213
11214    @classmethod
11215    def from_dict(cls, d):
11216        return cls(
11217            meta=d.get('meta'),
11218            rate_limit=d.get('rate_limit'),
11219            secret_store=d.get('secret_store'),
11220        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
11181    def __init__(
11182        self,
11183        meta=None,
11184        rate_limit=None,
11185        secret_store=None,
11186    ):
11187        self.meta = meta if meta is not None else None
11188        '''
11189         Reserved for future use.
11190        '''
11191        self.rate_limit = rate_limit if rate_limit is not None else None
11192        '''
11193         Rate limit information.
11194        '''
11195        self.secret_store = secret_store if secret_store is not None else None
11196        '''
11197         The created SecretStore.
11198        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11207    def to_dict(self):
11208        return {
11209            'meta': self.meta,
11210            'rate_limit': self.rate_limit,
11211            'secret_store': self.secret_store,
11212        }
@classmethod
def from_dict(cls, d)
11214    @classmethod
11215    def from_dict(cls, d):
11216        return cls(
11217            meta=d.get('meta'),
11218            rate_limit=d.get('rate_limit'),
11219            secret_store=d.get('secret_store'),
11220        )
class SecretStoreDeleteResponse:
11223class SecretStoreDeleteResponse:
11224    '''
11225         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11226    '''
11227    __slots__ = [
11228        'meta',
11229        'rate_limit',
11230    ]
11231
11232    def __init__(
11233        self,
11234        meta=None,
11235        rate_limit=None,
11236    ):
11237        self.meta = meta if meta is not None else None
11238        '''
11239         Reserved for future use.
11240        '''
11241        self.rate_limit = rate_limit if rate_limit is not None else None
11242        '''
11243         Rate limit information.
11244        '''
11245
11246    def __repr__(self):
11247        return '<sdm.SecretStoreDeleteResponse ' + \
11248            'meta: ' + repr(self.meta) + ' ' +\
11249            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11250            '>'
11251
11252    def to_dict(self):
11253        return {
11254            'meta': self.meta,
11255            'rate_limit': self.rate_limit,
11256        }
11257
11258    @classmethod
11259    def from_dict(cls, d):
11260        return cls(
11261            meta=d.get('meta'),
11262            rate_limit=d.get('rate_limit'),
11263        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11232    def __init__(
11233        self,
11234        meta=None,
11235        rate_limit=None,
11236    ):
11237        self.meta = meta if meta is not None else None
11238        '''
11239         Reserved for future use.
11240        '''
11241        self.rate_limit = rate_limit if rate_limit is not None else None
11242        '''
11243         Rate limit information.
11244        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11252    def to_dict(self):
11253        return {
11254            'meta': self.meta,
11255            'rate_limit': self.rate_limit,
11256        }
@classmethod
def from_dict(cls, d)
11258    @classmethod
11259    def from_dict(cls, d):
11260        return cls(
11261            meta=d.get('meta'),
11262            rate_limit=d.get('rate_limit'),
11263        )
class SecretStoreGetResponse:
11266class SecretStoreGetResponse:
11267    '''
11268         SecretStoreGetResponse returns a requested SecretStore.
11269    '''
11270    __slots__ = [
11271        'meta',
11272        'rate_limit',
11273        'secret_store',
11274    ]
11275
11276    def __init__(
11277        self,
11278        meta=None,
11279        rate_limit=None,
11280        secret_store=None,
11281    ):
11282        self.meta = meta if meta is not None else None
11283        '''
11284         Reserved for future use.
11285        '''
11286        self.rate_limit = rate_limit if rate_limit is not None else None
11287        '''
11288         Rate limit information.
11289        '''
11290        self.secret_store = secret_store if secret_store is not None else None
11291        '''
11292         The requested SecretStore.
11293        '''
11294
11295    def __repr__(self):
11296        return '<sdm.SecretStoreGetResponse ' + \
11297            'meta: ' + repr(self.meta) + ' ' +\
11298            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11299            'secret_store: ' + repr(self.secret_store) + ' ' +\
11300            '>'
11301
11302    def to_dict(self):
11303        return {
11304            'meta': self.meta,
11305            'rate_limit': self.rate_limit,
11306            'secret_store': self.secret_store,
11307        }
11308
11309    @classmethod
11310    def from_dict(cls, d):
11311        return cls(
11312            meta=d.get('meta'),
11313            rate_limit=d.get('rate_limit'),
11314            secret_store=d.get('secret_store'),
11315        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
11276    def __init__(
11277        self,
11278        meta=None,
11279        rate_limit=None,
11280        secret_store=None,
11281    ):
11282        self.meta = meta if meta is not None else None
11283        '''
11284         Reserved for future use.
11285        '''
11286        self.rate_limit = rate_limit if rate_limit is not None else None
11287        '''
11288         Rate limit information.
11289        '''
11290        self.secret_store = secret_store if secret_store is not None else None
11291        '''
11292         The requested SecretStore.
11293        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
11302    def to_dict(self):
11303        return {
11304            'meta': self.meta,
11305            'rate_limit': self.rate_limit,
11306            'secret_store': self.secret_store,
11307        }
@classmethod
def from_dict(cls, d)
11309    @classmethod
11310    def from_dict(cls, d):
11311        return cls(
11312            meta=d.get('meta'),
11313            rate_limit=d.get('rate_limit'),
11314            secret_store=d.get('secret_store'),
11315        )
class SecretStoreUpdateResponse:
11318class SecretStoreUpdateResponse:
11319    '''
11320         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11321     a SecretStoreUpdateRequest.
11322    '''
11323    __slots__ = [
11324        'meta',
11325        'rate_limit',
11326        'secret_store',
11327    ]
11328
11329    def __init__(
11330        self,
11331        meta=None,
11332        rate_limit=None,
11333        secret_store=None,
11334    ):
11335        self.meta = meta if meta is not None else None
11336        '''
11337         Reserved for future use.
11338        '''
11339        self.rate_limit = rate_limit if rate_limit is not None else None
11340        '''
11341         Rate limit information.
11342        '''
11343        self.secret_store = secret_store if secret_store is not None else None
11344        '''
11345         The updated SecretStore.
11346        '''
11347
11348    def __repr__(self):
11349        return '<sdm.SecretStoreUpdateResponse ' + \
11350            'meta: ' + repr(self.meta) + ' ' +\
11351            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11352            'secret_store: ' + repr(self.secret_store) + ' ' +\
11353            '>'
11354
11355    def to_dict(self):
11356        return {
11357            'meta': self.meta,
11358            'rate_limit': self.rate_limit,
11359            'secret_store': self.secret_store,
11360        }
11361
11362    @classmethod
11363    def from_dict(cls, d):
11364        return cls(
11365            meta=d.get('meta'),
11366            rate_limit=d.get('rate_limit'),
11367            secret_store=d.get('secret_store'),
11368        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
11329    def __init__(
11330        self,
11331        meta=None,
11332        rate_limit=None,
11333        secret_store=None,
11334    ):
11335        self.meta = meta if meta is not None else None
11336        '''
11337         Reserved for future use.
11338        '''
11339        self.rate_limit = rate_limit if rate_limit is not None else None
11340        '''
11341         Rate limit information.
11342        '''
11343        self.secret_store = secret_store if secret_store is not None else None
11344        '''
11345         The updated SecretStore.
11346        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
11355    def to_dict(self):
11356        return {
11357            'meta': self.meta,
11358            'rate_limit': self.rate_limit,
11359            'secret_store': self.secret_store,
11360        }
@classmethod
def from_dict(cls, d)
11362    @classmethod
11363    def from_dict(cls, d):
11364        return cls(
11365            meta=d.get('meta'),
11366            rate_limit=d.get('rate_limit'),
11367            secret_store=d.get('secret_store'),
11368        )
class Service:
11371class Service:
11372    '''
11373         A Service is a service account that can connect to resources they are granted
11374     directly, or granted via roles. Services are typically automated jobs.
11375    '''
11376    __slots__ = [
11377        'id',
11378        'name',
11379        'suspended',
11380        'tags',
11381    ]
11382
11383    def __init__(
11384        self,
11385        id=None,
11386        name=None,
11387        suspended=None,
11388        tags=None,
11389    ):
11390        self.id = id if id is not None else ''
11391        '''
11392         Unique identifier of the Service.
11393        '''
11394        self.name = name if name is not None else ''
11395        '''
11396         Unique human-readable name of the Service.
11397        '''
11398        self.suspended = suspended if suspended is not None else False
11399        '''
11400         The Service's suspended state.
11401        '''
11402        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11403        '''
11404         Tags is a map of key, value pairs.
11405        '''
11406
11407    def __repr__(self):
11408        return '<sdm.Service ' + \
11409            'id: ' + repr(self.id) + ' ' +\
11410            'name: ' + repr(self.name) + ' ' +\
11411            'suspended: ' + repr(self.suspended) + ' ' +\
11412            'tags: ' + repr(self.tags) + ' ' +\
11413            '>'
11414
11415    def to_dict(self):
11416        return {
11417            'id': self.id,
11418            'name': self.name,
11419            'suspended': self.suspended,
11420            'tags': self.tags,
11421        }
11422
11423    @classmethod
11424    def from_dict(cls, d):
11425        return cls(
11426            id=d.get('id'),
11427            name=d.get('name'),
11428            suspended=d.get('suspended'),
11429            tags=d.get('tags'),
11430        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
11383    def __init__(
11384        self,
11385        id=None,
11386        name=None,
11387        suspended=None,
11388        tags=None,
11389    ):
11390        self.id = id if id is not None else ''
11391        '''
11392         Unique identifier of the Service.
11393        '''
11394        self.name = name if name is not None else ''
11395        '''
11396         Unique human-readable name of the Service.
11397        '''
11398        self.suspended = suspended if suspended is not None else False
11399        '''
11400         The Service's suspended state.
11401        '''
11402        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11403        '''
11404         Tags is a map of key, value pairs.
11405        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11415    def to_dict(self):
11416        return {
11417            'id': self.id,
11418            'name': self.name,
11419            'suspended': self.suspended,
11420            'tags': self.tags,
11421        }
@classmethod
def from_dict(cls, d)
11423    @classmethod
11424    def from_dict(cls, d):
11425        return cls(
11426            id=d.get('id'),
11427            name=d.get('name'),
11428            suspended=d.get('suspended'),
11429            tags=d.get('tags'),
11430        )
class SingleStore:
11433class SingleStore:
11434    __slots__ = [
11435        'bind_interface',
11436        'database',
11437        'egress_filter',
11438        'healthy',
11439        'hostname',
11440        'id',
11441        'name',
11442        'password',
11443        'port',
11444        'port_override',
11445        'secret_store_id',
11446        'tags',
11447        'username',
11448    ]
11449
11450    def __init__(
11451        self,
11452        bind_interface=None,
11453        database=None,
11454        egress_filter=None,
11455        healthy=None,
11456        hostname=None,
11457        id=None,
11458        name=None,
11459        password=None,
11460        port=None,
11461        port_override=None,
11462        secret_store_id=None,
11463        tags=None,
11464        username=None,
11465    ):
11466        self.bind_interface = bind_interface if bind_interface is not None else ''
11467        '''
11468         Bind interface
11469        '''
11470        self.database = database if database is not None else ''
11471        self.egress_filter = egress_filter if egress_filter is not None else ''
11472        '''
11473         A filter applied to the routing logic to pin datasource to nodes.
11474        '''
11475        self.healthy = healthy if healthy is not None else False
11476        '''
11477         True if the datasource is reachable and the credentials are valid.
11478        '''
11479        self.hostname = hostname if hostname is not None else ''
11480        self.id = id if id is not None else ''
11481        '''
11482         Unique identifier of the Resource.
11483        '''
11484        self.name = name if name is not None else ''
11485        '''
11486         Unique human-readable name of the Resource.
11487        '''
11488        self.password = password if password is not None else ''
11489        self.port = port if port is not None else 0
11490        self.port_override = port_override if port_override is not None else 0
11491        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11492        '''
11493         ID of the secret store containing credentials for this resource, if any.
11494        '''
11495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11496        '''
11497         Tags is a map of key, value pairs.
11498        '''
11499        self.username = username if username is not None else ''
11500
11501    def __repr__(self):
11502        return '<sdm.SingleStore ' + \
11503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11504            'database: ' + repr(self.database) + ' ' +\
11505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11506            'healthy: ' + repr(self.healthy) + ' ' +\
11507            'hostname: ' + repr(self.hostname) + ' ' +\
11508            'id: ' + repr(self.id) + ' ' +\
11509            'name: ' + repr(self.name) + ' ' +\
11510            'password: ' + repr(self.password) + ' ' +\
11511            'port: ' + repr(self.port) + ' ' +\
11512            'port_override: ' + repr(self.port_override) + ' ' +\
11513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11514            'tags: ' + repr(self.tags) + ' ' +\
11515            'username: ' + repr(self.username) + ' ' +\
11516            '>'
11517
11518    def to_dict(self):
11519        return {
11520            'bind_interface': self.bind_interface,
11521            'database': self.database,
11522            'egress_filter': self.egress_filter,
11523            'healthy': self.healthy,
11524            'hostname': self.hostname,
11525            'id': self.id,
11526            'name': self.name,
11527            'password': self.password,
11528            'port': self.port,
11529            'port_override': self.port_override,
11530            'secret_store_id': self.secret_store_id,
11531            'tags': self.tags,
11532            'username': self.username,
11533        }
11534
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            bind_interface=d.get('bind_interface'),
11539            database=d.get('database'),
11540            egress_filter=d.get('egress_filter'),
11541            healthy=d.get('healthy'),
11542            hostname=d.get('hostname'),
11543            id=d.get('id'),
11544            name=d.get('name'),
11545            password=d.get('password'),
11546            port=d.get('port'),
11547            port_override=d.get('port_override'),
11548            secret_store_id=d.get('secret_store_id'),
11549            tags=d.get('tags'),
11550            username=d.get('username'),
11551        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11450    def __init__(
11451        self,
11452        bind_interface=None,
11453        database=None,
11454        egress_filter=None,
11455        healthy=None,
11456        hostname=None,
11457        id=None,
11458        name=None,
11459        password=None,
11460        port=None,
11461        port_override=None,
11462        secret_store_id=None,
11463        tags=None,
11464        username=None,
11465    ):
11466        self.bind_interface = bind_interface if bind_interface is not None else ''
11467        '''
11468         Bind interface
11469        '''
11470        self.database = database if database is not None else ''
11471        self.egress_filter = egress_filter if egress_filter is not None else ''
11472        '''
11473         A filter applied to the routing logic to pin datasource to nodes.
11474        '''
11475        self.healthy = healthy if healthy is not None else False
11476        '''
11477         True if the datasource is reachable and the credentials are valid.
11478        '''
11479        self.hostname = hostname if hostname is not None else ''
11480        self.id = id if id is not None else ''
11481        '''
11482         Unique identifier of the Resource.
11483        '''
11484        self.name = name if name is not None else ''
11485        '''
11486         Unique human-readable name of the Resource.
11487        '''
11488        self.password = password if password is not None else ''
11489        self.port = port if port is not None else 0
11490        self.port_override = port_override if port_override is not None else 0
11491        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11492        '''
11493         ID of the secret store containing credentials for this resource, if any.
11494        '''
11495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11496        '''
11497         Tags is a map of key, value pairs.
11498        '''
11499        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11518    def to_dict(self):
11519        return {
11520            'bind_interface': self.bind_interface,
11521            'database': self.database,
11522            'egress_filter': self.egress_filter,
11523            'healthy': self.healthy,
11524            'hostname': self.hostname,
11525            'id': self.id,
11526            'name': self.name,
11527            'password': self.password,
11528            'port': self.port,
11529            'port_override': self.port_override,
11530            'secret_store_id': self.secret_store_id,
11531            'tags': self.tags,
11532            'username': self.username,
11533        }
@classmethod
def from_dict(cls, d)
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            bind_interface=d.get('bind_interface'),
11539            database=d.get('database'),
11540            egress_filter=d.get('egress_filter'),
11541            healthy=d.get('healthy'),
11542            hostname=d.get('hostname'),
11543            id=d.get('id'),
11544            name=d.get('name'),
11545            password=d.get('password'),
11546            port=d.get('port'),
11547            port_override=d.get('port_override'),
11548            secret_store_id=d.get('secret_store_id'),
11549            tags=d.get('tags'),
11550            username=d.get('username'),
11551        )
class Snowflake:
11554class Snowflake:
11555    __slots__ = [
11556        'bind_interface',
11557        'database',
11558        'egress_filter',
11559        'healthy',
11560        'hostname',
11561        'id',
11562        'name',
11563        'password',
11564        'port_override',
11565        'schema',
11566        'secret_store_id',
11567        'tags',
11568        'username',
11569    ]
11570
11571    def __init__(
11572        self,
11573        bind_interface=None,
11574        database=None,
11575        egress_filter=None,
11576        healthy=None,
11577        hostname=None,
11578        id=None,
11579        name=None,
11580        password=None,
11581        port_override=None,
11582        schema=None,
11583        secret_store_id=None,
11584        tags=None,
11585        username=None,
11586    ):
11587        self.bind_interface = bind_interface if bind_interface is not None else ''
11588        '''
11589         Bind interface
11590        '''
11591        self.database = database if database is not None else ''
11592        self.egress_filter = egress_filter if egress_filter is not None else ''
11593        '''
11594         A filter applied to the routing logic to pin datasource to nodes.
11595        '''
11596        self.healthy = healthy if healthy is not None else False
11597        '''
11598         True if the datasource is reachable and the credentials are valid.
11599        '''
11600        self.hostname = hostname if hostname is not None else ''
11601        self.id = id if id is not None else ''
11602        '''
11603         Unique identifier of the Resource.
11604        '''
11605        self.name = name if name is not None else ''
11606        '''
11607         Unique human-readable name of the Resource.
11608        '''
11609        self.password = password if password is not None else ''
11610        self.port_override = port_override if port_override is not None else 0
11611        self.schema = schema if schema is not None else ''
11612        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11613        '''
11614         ID of the secret store containing credentials for this resource, if any.
11615        '''
11616        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11617        '''
11618         Tags is a map of key, value pairs.
11619        '''
11620        self.username = username if username is not None else ''
11621
11622    def __repr__(self):
11623        return '<sdm.Snowflake ' + \
11624            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11625            'database: ' + repr(self.database) + ' ' +\
11626            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11627            'healthy: ' + repr(self.healthy) + ' ' +\
11628            'hostname: ' + repr(self.hostname) + ' ' +\
11629            'id: ' + repr(self.id) + ' ' +\
11630            'name: ' + repr(self.name) + ' ' +\
11631            'password: ' + repr(self.password) + ' ' +\
11632            'port_override: ' + repr(self.port_override) + ' ' +\
11633            'schema: ' + repr(self.schema) + ' ' +\
11634            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11635            'tags: ' + repr(self.tags) + ' ' +\
11636            'username: ' + repr(self.username) + ' ' +\
11637            '>'
11638
11639    def to_dict(self):
11640        return {
11641            'bind_interface': self.bind_interface,
11642            'database': self.database,
11643            'egress_filter': self.egress_filter,
11644            'healthy': self.healthy,
11645            'hostname': self.hostname,
11646            'id': self.id,
11647            'name': self.name,
11648            'password': self.password,
11649            'port_override': self.port_override,
11650            'schema': self.schema,
11651            'secret_store_id': self.secret_store_id,
11652            'tags': self.tags,
11653            'username': self.username,
11654        }
11655
11656    @classmethod
11657    def from_dict(cls, d):
11658        return cls(
11659            bind_interface=d.get('bind_interface'),
11660            database=d.get('database'),
11661            egress_filter=d.get('egress_filter'),
11662            healthy=d.get('healthy'),
11663            hostname=d.get('hostname'),
11664            id=d.get('id'),
11665            name=d.get('name'),
11666            password=d.get('password'),
11667            port_override=d.get('port_override'),
11668            schema=d.get('schema'),
11669            secret_store_id=d.get('secret_store_id'),
11670            tags=d.get('tags'),
11671            username=d.get('username'),
11672        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11571    def __init__(
11572        self,
11573        bind_interface=None,
11574        database=None,
11575        egress_filter=None,
11576        healthy=None,
11577        hostname=None,
11578        id=None,
11579        name=None,
11580        password=None,
11581        port_override=None,
11582        schema=None,
11583        secret_store_id=None,
11584        tags=None,
11585        username=None,
11586    ):
11587        self.bind_interface = bind_interface if bind_interface is not None else ''
11588        '''
11589         Bind interface
11590        '''
11591        self.database = database if database is not None else ''
11592        self.egress_filter = egress_filter if egress_filter is not None else ''
11593        '''
11594         A filter applied to the routing logic to pin datasource to nodes.
11595        '''
11596        self.healthy = healthy if healthy is not None else False
11597        '''
11598         True if the datasource is reachable and the credentials are valid.
11599        '''
11600        self.hostname = hostname if hostname is not None else ''
11601        self.id = id if id is not None else ''
11602        '''
11603         Unique identifier of the Resource.
11604        '''
11605        self.name = name if name is not None else ''
11606        '''
11607         Unique human-readable name of the Resource.
11608        '''
11609        self.password = password if password is not None else ''
11610        self.port_override = port_override if port_override is not None else 0
11611        self.schema = schema if schema is not None else ''
11612        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11613        '''
11614         ID of the secret store containing credentials for this resource, if any.
11615        '''
11616        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11617        '''
11618         Tags is a map of key, value pairs.
11619        '''
11620        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11639    def to_dict(self):
11640        return {
11641            'bind_interface': self.bind_interface,
11642            'database': self.database,
11643            'egress_filter': self.egress_filter,
11644            'healthy': self.healthy,
11645            'hostname': self.hostname,
11646            'id': self.id,
11647            'name': self.name,
11648            'password': self.password,
11649            'port_override': self.port_override,
11650            'schema': self.schema,
11651            'secret_store_id': self.secret_store_id,
11652            'tags': self.tags,
11653            'username': self.username,
11654        }
@classmethod
def from_dict(cls, d)
11656    @classmethod
11657    def from_dict(cls, d):
11658        return cls(
11659            bind_interface=d.get('bind_interface'),
11660            database=d.get('database'),
11661            egress_filter=d.get('egress_filter'),
11662            healthy=d.get('healthy'),
11663            hostname=d.get('hostname'),
11664            id=d.get('id'),
11665            name=d.get('name'),
11666            password=d.get('password'),
11667            port_override=d.get('port_override'),
11668            schema=d.get('schema'),
11669            secret_store_id=d.get('secret_store_id'),
11670            tags=d.get('tags'),
11671            username=d.get('username'),
11672        )
class Snowsight:
11675class Snowsight:
11676    '''
11677    Snowsight is currently unstable, and its API may change, or it may be removed,
11678    without a major version bump.
11679    '''
11680    __slots__ = [
11681        'bind_interface',
11682        'egress_filter',
11683        'healthcheck_username',
11684        'healthy',
11685        'id',
11686        'name',
11687        'port_override',
11688        'samlmetadata',
11689        'secret_store_id',
11690        'subdomain',
11691        'tags',
11692    ]
11693
11694    def __init__(
11695        self,
11696        bind_interface=None,
11697        egress_filter=None,
11698        healthcheck_username=None,
11699        healthy=None,
11700        id=None,
11701        name=None,
11702        port_override=None,
11703        samlmetadata=None,
11704        secret_store_id=None,
11705        subdomain=None,
11706        tags=None,
11707    ):
11708        self.bind_interface = bind_interface if bind_interface is not None else ''
11709        '''
11710         Bind interface
11711        '''
11712        self.egress_filter = egress_filter if egress_filter is not None else ''
11713        '''
11714         A filter applied to the routing logic to pin datasource to nodes.
11715        '''
11716        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11717        self.healthy = healthy if healthy is not None else False
11718        '''
11719         True if the datasource is reachable and the credentials are valid.
11720        '''
11721        self.id = id if id is not None else ''
11722        '''
11723         Unique identifier of the Resource.
11724        '''
11725        self.name = name if name is not None else ''
11726        '''
11727         Unique human-readable name of the Resource.
11728        '''
11729        self.port_override = port_override if port_override is not None else 0
11730        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11732        '''
11733         ID of the secret store containing credentials for this resource, if any.
11734        '''
11735        self.subdomain = subdomain if subdomain is not None else ''
11736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11737        '''
11738         Tags is a map of key, value pairs.
11739        '''
11740
11741    def __repr__(self):
11742        return '<sdm.Snowsight ' + \
11743            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11744            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11745            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11746            'healthy: ' + repr(self.healthy) + ' ' +\
11747            'id: ' + repr(self.id) + ' ' +\
11748            'name: ' + repr(self.name) + ' ' +\
11749            'port_override: ' + repr(self.port_override) + ' ' +\
11750            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11751            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11752            'subdomain: ' + repr(self.subdomain) + ' ' +\
11753            'tags: ' + repr(self.tags) + ' ' +\
11754            '>'
11755
11756    def to_dict(self):
11757        return {
11758            'bind_interface': self.bind_interface,
11759            'egress_filter': self.egress_filter,
11760            'healthcheck_username': self.healthcheck_username,
11761            'healthy': self.healthy,
11762            'id': self.id,
11763            'name': self.name,
11764            'port_override': self.port_override,
11765            'samlmetadata': self.samlmetadata,
11766            'secret_store_id': self.secret_store_id,
11767            'subdomain': self.subdomain,
11768            'tags': self.tags,
11769        }
11770
11771    @classmethod
11772    def from_dict(cls, d):
11773        return cls(
11774            bind_interface=d.get('bind_interface'),
11775            egress_filter=d.get('egress_filter'),
11776            healthcheck_username=d.get('healthcheck_username'),
11777            healthy=d.get('healthy'),
11778            id=d.get('id'),
11779            name=d.get('name'),
11780            port_override=d.get('port_override'),
11781            samlmetadata=d.get('samlmetadata'),
11782            secret_store_id=d.get('secret_store_id'),
11783            subdomain=d.get('subdomain'),
11784            tags=d.get('tags'),
11785        )

Snowsight is currently unstable, and its API may change, or it may be removed, without a major version bump.

Snowsight( bind_interface=None, egress_filter=None, healthcheck_username=None, healthy=None, id=None, name=None, port_override=None, samlmetadata=None, secret_store_id=None, subdomain=None, tags=None)
11694    def __init__(
11695        self,
11696        bind_interface=None,
11697        egress_filter=None,
11698        healthcheck_username=None,
11699        healthy=None,
11700        id=None,
11701        name=None,
11702        port_override=None,
11703        samlmetadata=None,
11704        secret_store_id=None,
11705        subdomain=None,
11706        tags=None,
11707    ):
11708        self.bind_interface = bind_interface if bind_interface is not None else ''
11709        '''
11710         Bind interface
11711        '''
11712        self.egress_filter = egress_filter if egress_filter is not None else ''
11713        '''
11714         A filter applied to the routing logic to pin datasource to nodes.
11715        '''
11716        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11717        self.healthy = healthy if healthy is not None else False
11718        '''
11719         True if the datasource is reachable and the credentials are valid.
11720        '''
11721        self.id = id if id is not None else ''
11722        '''
11723         Unique identifier of the Resource.
11724        '''
11725        self.name = name if name is not None else ''
11726        '''
11727         Unique human-readable name of the Resource.
11728        '''
11729        self.port_override = port_override if port_override is not None else 0
11730        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11732        '''
11733         ID of the secret store containing credentials for this resource, if any.
11734        '''
11735        self.subdomain = subdomain if subdomain is not None else ''
11736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11737        '''
11738         Tags is a map of key, value pairs.
11739        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_username
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
samlmetadata
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
11756    def to_dict(self):
11757        return {
11758            'bind_interface': self.bind_interface,
11759            'egress_filter': self.egress_filter,
11760            'healthcheck_username': self.healthcheck_username,
11761            'healthy': self.healthy,
11762            'id': self.id,
11763            'name': self.name,
11764            'port_override': self.port_override,
11765            'samlmetadata': self.samlmetadata,
11766            'secret_store_id': self.secret_store_id,
11767            'subdomain': self.subdomain,
11768            'tags': self.tags,
11769        }
@classmethod
def from_dict(cls, d)
11771    @classmethod
11772    def from_dict(cls, d):
11773        return cls(
11774            bind_interface=d.get('bind_interface'),
11775            egress_filter=d.get('egress_filter'),
11776            healthcheck_username=d.get('healthcheck_username'),
11777            healthy=d.get('healthy'),
11778            id=d.get('id'),
11779            name=d.get('name'),
11780            port_override=d.get('port_override'),
11781            samlmetadata=d.get('samlmetadata'),
11782            secret_store_id=d.get('secret_store_id'),
11783            subdomain=d.get('subdomain'),
11784            tags=d.get('tags'),
11785        )
class Sybase:
11788class Sybase:
11789    __slots__ = [
11790        'bind_interface',
11791        'egress_filter',
11792        'healthy',
11793        'hostname',
11794        'id',
11795        'name',
11796        'password',
11797        'port',
11798        'port_override',
11799        'secret_store_id',
11800        'tags',
11801        'username',
11802    ]
11803
11804    def __init__(
11805        self,
11806        bind_interface=None,
11807        egress_filter=None,
11808        healthy=None,
11809        hostname=None,
11810        id=None,
11811        name=None,
11812        password=None,
11813        port=None,
11814        port_override=None,
11815        secret_store_id=None,
11816        tags=None,
11817        username=None,
11818    ):
11819        self.bind_interface = bind_interface if bind_interface is not None else ''
11820        '''
11821         Bind interface
11822        '''
11823        self.egress_filter = egress_filter if egress_filter is not None else ''
11824        '''
11825         A filter applied to the routing logic to pin datasource to nodes.
11826        '''
11827        self.healthy = healthy if healthy is not None else False
11828        '''
11829         True if the datasource is reachable and the credentials are valid.
11830        '''
11831        self.hostname = hostname if hostname is not None else ''
11832        self.id = id if id is not None else ''
11833        '''
11834         Unique identifier of the Resource.
11835        '''
11836        self.name = name if name is not None else ''
11837        '''
11838         Unique human-readable name of the Resource.
11839        '''
11840        self.password = password if password is not None else ''
11841        self.port = port if port is not None else 0
11842        self.port_override = port_override if port_override is not None else 0
11843        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11844        '''
11845         ID of the secret store containing credentials for this resource, if any.
11846        '''
11847        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11848        '''
11849         Tags is a map of key, value pairs.
11850        '''
11851        self.username = username if username is not None else ''
11852
11853    def __repr__(self):
11854        return '<sdm.Sybase ' + \
11855            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11856            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11857            'healthy: ' + repr(self.healthy) + ' ' +\
11858            'hostname: ' + repr(self.hostname) + ' ' +\
11859            'id: ' + repr(self.id) + ' ' +\
11860            'name: ' + repr(self.name) + ' ' +\
11861            'password: ' + repr(self.password) + ' ' +\
11862            'port: ' + repr(self.port) + ' ' +\
11863            'port_override: ' + repr(self.port_override) + ' ' +\
11864            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11865            'tags: ' + repr(self.tags) + ' ' +\
11866            'username: ' + repr(self.username) + ' ' +\
11867            '>'
11868
11869    def to_dict(self):
11870        return {
11871            'bind_interface': self.bind_interface,
11872            'egress_filter': self.egress_filter,
11873            'healthy': self.healthy,
11874            'hostname': self.hostname,
11875            'id': self.id,
11876            'name': self.name,
11877            'password': self.password,
11878            'port': self.port,
11879            'port_override': self.port_override,
11880            'secret_store_id': self.secret_store_id,
11881            'tags': self.tags,
11882            'username': self.username,
11883        }
11884
11885    @classmethod
11886    def from_dict(cls, d):
11887        return cls(
11888            bind_interface=d.get('bind_interface'),
11889            egress_filter=d.get('egress_filter'),
11890            healthy=d.get('healthy'),
11891            hostname=d.get('hostname'),
11892            id=d.get('id'),
11893            name=d.get('name'),
11894            password=d.get('password'),
11895            port=d.get('port'),
11896            port_override=d.get('port_override'),
11897            secret_store_id=d.get('secret_store_id'),
11898            tags=d.get('tags'),
11899            username=d.get('username'),
11900        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11804    def __init__(
11805        self,
11806        bind_interface=None,
11807        egress_filter=None,
11808        healthy=None,
11809        hostname=None,
11810        id=None,
11811        name=None,
11812        password=None,
11813        port=None,
11814        port_override=None,
11815        secret_store_id=None,
11816        tags=None,
11817        username=None,
11818    ):
11819        self.bind_interface = bind_interface if bind_interface is not None else ''
11820        '''
11821         Bind interface
11822        '''
11823        self.egress_filter = egress_filter if egress_filter is not None else ''
11824        '''
11825         A filter applied to the routing logic to pin datasource to nodes.
11826        '''
11827        self.healthy = healthy if healthy is not None else False
11828        '''
11829         True if the datasource is reachable and the credentials are valid.
11830        '''
11831        self.hostname = hostname if hostname is not None else ''
11832        self.id = id if id is not None else ''
11833        '''
11834         Unique identifier of the Resource.
11835        '''
11836        self.name = name if name is not None else ''
11837        '''
11838         Unique human-readable name of the Resource.
11839        '''
11840        self.password = password if password is not None else ''
11841        self.port = port if port is not None else 0
11842        self.port_override = port_override if port_override is not None else 0
11843        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11844        '''
11845         ID of the secret store containing credentials for this resource, if any.
11846        '''
11847        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11848        '''
11849         Tags is a map of key, value pairs.
11850        '''
11851        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11869    def to_dict(self):
11870        return {
11871            'bind_interface': self.bind_interface,
11872            'egress_filter': self.egress_filter,
11873            'healthy': self.healthy,
11874            'hostname': self.hostname,
11875            'id': self.id,
11876            'name': self.name,
11877            'password': self.password,
11878            'port': self.port,
11879            'port_override': self.port_override,
11880            'secret_store_id': self.secret_store_id,
11881            'tags': self.tags,
11882            'username': self.username,
11883        }
@classmethod
def from_dict(cls, d)
11885    @classmethod
11886    def from_dict(cls, d):
11887        return cls(
11888            bind_interface=d.get('bind_interface'),
11889            egress_filter=d.get('egress_filter'),
11890            healthy=d.get('healthy'),
11891            hostname=d.get('hostname'),
11892            id=d.get('id'),
11893            name=d.get('name'),
11894            password=d.get('password'),
11895            port=d.get('port'),
11896            port_override=d.get('port_override'),
11897            secret_store_id=d.get('secret_store_id'),
11898            tags=d.get('tags'),
11899            username=d.get('username'),
11900        )
class SybaseIQ:
11903class SybaseIQ:
11904    __slots__ = [
11905        'bind_interface',
11906        'egress_filter',
11907        'healthy',
11908        'hostname',
11909        'id',
11910        'name',
11911        'password',
11912        'port',
11913        'port_override',
11914        'secret_store_id',
11915        'tags',
11916        'username',
11917    ]
11918
11919    def __init__(
11920        self,
11921        bind_interface=None,
11922        egress_filter=None,
11923        healthy=None,
11924        hostname=None,
11925        id=None,
11926        name=None,
11927        password=None,
11928        port=None,
11929        port_override=None,
11930        secret_store_id=None,
11931        tags=None,
11932        username=None,
11933    ):
11934        self.bind_interface = bind_interface if bind_interface is not None else ''
11935        '''
11936         Bind interface
11937        '''
11938        self.egress_filter = egress_filter if egress_filter is not None else ''
11939        '''
11940         A filter applied to the routing logic to pin datasource to nodes.
11941        '''
11942        self.healthy = healthy if healthy is not None else False
11943        '''
11944         True if the datasource is reachable and the credentials are valid.
11945        '''
11946        self.hostname = hostname if hostname is not None else ''
11947        self.id = id if id is not None else ''
11948        '''
11949         Unique identifier of the Resource.
11950        '''
11951        self.name = name if name is not None else ''
11952        '''
11953         Unique human-readable name of the Resource.
11954        '''
11955        self.password = password if password is not None else ''
11956        self.port = port if port is not None else 0
11957        self.port_override = port_override if port_override is not None else 0
11958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11959        '''
11960         ID of the secret store containing credentials for this resource, if any.
11961        '''
11962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11963        '''
11964         Tags is a map of key, value pairs.
11965        '''
11966        self.username = username if username is not None else ''
11967
11968    def __repr__(self):
11969        return '<sdm.SybaseIQ ' + \
11970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11971            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11972            'healthy: ' + repr(self.healthy) + ' ' +\
11973            'hostname: ' + repr(self.hostname) + ' ' +\
11974            'id: ' + repr(self.id) + ' ' +\
11975            'name: ' + repr(self.name) + ' ' +\
11976            'password: ' + repr(self.password) + ' ' +\
11977            'port: ' + repr(self.port) + ' ' +\
11978            'port_override: ' + repr(self.port_override) + ' ' +\
11979            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11980            'tags: ' + repr(self.tags) + ' ' +\
11981            'username: ' + repr(self.username) + ' ' +\
11982            '>'
11983
11984    def to_dict(self):
11985        return {
11986            'bind_interface': self.bind_interface,
11987            'egress_filter': self.egress_filter,
11988            'healthy': self.healthy,
11989            'hostname': self.hostname,
11990            'id': self.id,
11991            'name': self.name,
11992            'password': self.password,
11993            'port': self.port,
11994            'port_override': self.port_override,
11995            'secret_store_id': self.secret_store_id,
11996            'tags': self.tags,
11997            'username': self.username,
11998        }
11999
12000    @classmethod
12001    def from_dict(cls, d):
12002        return cls(
12003            bind_interface=d.get('bind_interface'),
12004            egress_filter=d.get('egress_filter'),
12005            healthy=d.get('healthy'),
12006            hostname=d.get('hostname'),
12007            id=d.get('id'),
12008            name=d.get('name'),
12009            password=d.get('password'),
12010            port=d.get('port'),
12011            port_override=d.get('port_override'),
12012            secret_store_id=d.get('secret_store_id'),
12013            tags=d.get('tags'),
12014            username=d.get('username'),
12015        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11919    def __init__(
11920        self,
11921        bind_interface=None,
11922        egress_filter=None,
11923        healthy=None,
11924        hostname=None,
11925        id=None,
11926        name=None,
11927        password=None,
11928        port=None,
11929        port_override=None,
11930        secret_store_id=None,
11931        tags=None,
11932        username=None,
11933    ):
11934        self.bind_interface = bind_interface if bind_interface is not None else ''
11935        '''
11936         Bind interface
11937        '''
11938        self.egress_filter = egress_filter if egress_filter is not None else ''
11939        '''
11940         A filter applied to the routing logic to pin datasource to nodes.
11941        '''
11942        self.healthy = healthy if healthy is not None else False
11943        '''
11944         True if the datasource is reachable and the credentials are valid.
11945        '''
11946        self.hostname = hostname if hostname is not None else ''
11947        self.id = id if id is not None else ''
11948        '''
11949         Unique identifier of the Resource.
11950        '''
11951        self.name = name if name is not None else ''
11952        '''
11953         Unique human-readable name of the Resource.
11954        '''
11955        self.password = password if password is not None else ''
11956        self.port = port if port is not None else 0
11957        self.port_override = port_override if port_override is not None else 0
11958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11959        '''
11960         ID of the secret store containing credentials for this resource, if any.
11961        '''
11962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11963        '''
11964         Tags is a map of key, value pairs.
11965        '''
11966        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11984    def to_dict(self):
11985        return {
11986            'bind_interface': self.bind_interface,
11987            'egress_filter': self.egress_filter,
11988            'healthy': self.healthy,
11989            'hostname': self.hostname,
11990            'id': self.id,
11991            'name': self.name,
11992            'password': self.password,
11993            'port': self.port,
11994            'port_override': self.port_override,
11995            'secret_store_id': self.secret_store_id,
11996            'tags': self.tags,
11997            'username': self.username,
11998        }
@classmethod
def from_dict(cls, d)
12000    @classmethod
12001    def from_dict(cls, d):
12002        return cls(
12003            bind_interface=d.get('bind_interface'),
12004            egress_filter=d.get('egress_filter'),
12005            healthy=d.get('healthy'),
12006            hostname=d.get('hostname'),
12007            id=d.get('id'),
12008            name=d.get('name'),
12009            password=d.get('password'),
12010            port=d.get('port'),
12011            port_override=d.get('port_override'),
12012            secret_store_id=d.get('secret_store_id'),
12013            tags=d.get('tags'),
12014            username=d.get('username'),
12015        )
class Tag:
12018class Tag:
12019    __slots__ = [
12020        'name',
12021        'value',
12022    ]
12023
12024    def __init__(
12025        self,
12026        name=None,
12027        value=None,
12028    ):
12029        self.name = name if name is not None else ''
12030        self.value = value if value is not None else ''
12031
12032    def __repr__(self):
12033        return '<sdm.Tag ' + \
12034            'name: ' + repr(self.name) + ' ' +\
12035            'value: ' + repr(self.value) + ' ' +\
12036            '>'
12037
12038    def to_dict(self):
12039        return {
12040            'name': self.name,
12041            'value': self.value,
12042        }
12043
12044    @classmethod
12045    def from_dict(cls, d):
12046        return cls(
12047            name=d.get('name'),
12048            value=d.get('value'),
12049        )
Tag(name=None, value=None)
12024    def __init__(
12025        self,
12026        name=None,
12027        value=None,
12028    ):
12029        self.name = name if name is not None else ''
12030        self.value = value if value is not None else ''
name
value
def to_dict(self)
12038    def to_dict(self):
12039        return {
12040            'name': self.name,
12041            'value': self.value,
12042        }
@classmethod
def from_dict(cls, d)
12044    @classmethod
12045    def from_dict(cls, d):
12046        return cls(
12047            name=d.get('name'),
12048            value=d.get('value'),
12049        )
class Teradata:
12052class Teradata:
12053    __slots__ = [
12054        'bind_interface',
12055        'egress_filter',
12056        'healthy',
12057        'hostname',
12058        'id',
12059        'name',
12060        'password',
12061        'port',
12062        'port_override',
12063        'secret_store_id',
12064        'tags',
12065        'username',
12066    ]
12067
12068    def __init__(
12069        self,
12070        bind_interface=None,
12071        egress_filter=None,
12072        healthy=None,
12073        hostname=None,
12074        id=None,
12075        name=None,
12076        password=None,
12077        port=None,
12078        port_override=None,
12079        secret_store_id=None,
12080        tags=None,
12081        username=None,
12082    ):
12083        self.bind_interface = bind_interface if bind_interface is not None else ''
12084        '''
12085         Bind interface
12086        '''
12087        self.egress_filter = egress_filter if egress_filter is not None else ''
12088        '''
12089         A filter applied to the routing logic to pin datasource to nodes.
12090        '''
12091        self.healthy = healthy if healthy is not None else False
12092        '''
12093         True if the datasource is reachable and the credentials are valid.
12094        '''
12095        self.hostname = hostname if hostname is not None else ''
12096        self.id = id if id is not None else ''
12097        '''
12098         Unique identifier of the Resource.
12099        '''
12100        self.name = name if name is not None else ''
12101        '''
12102         Unique human-readable name of the Resource.
12103        '''
12104        self.password = password if password is not None else ''
12105        self.port = port if port is not None else 0
12106        self.port_override = port_override if port_override is not None else 0
12107        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12108        '''
12109         ID of the secret store containing credentials for this resource, if any.
12110        '''
12111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12112        '''
12113         Tags is a map of key, value pairs.
12114        '''
12115        self.username = username if username is not None else ''
12116
12117    def __repr__(self):
12118        return '<sdm.Teradata ' + \
12119            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12120            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12121            'healthy: ' + repr(self.healthy) + ' ' +\
12122            'hostname: ' + repr(self.hostname) + ' ' +\
12123            'id: ' + repr(self.id) + ' ' +\
12124            'name: ' + repr(self.name) + ' ' +\
12125            'password: ' + repr(self.password) + ' ' +\
12126            'port: ' + repr(self.port) + ' ' +\
12127            'port_override: ' + repr(self.port_override) + ' ' +\
12128            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12129            'tags: ' + repr(self.tags) + ' ' +\
12130            'username: ' + repr(self.username) + ' ' +\
12131            '>'
12132
12133    def to_dict(self):
12134        return {
12135            'bind_interface': self.bind_interface,
12136            'egress_filter': self.egress_filter,
12137            'healthy': self.healthy,
12138            'hostname': self.hostname,
12139            'id': self.id,
12140            'name': self.name,
12141            'password': self.password,
12142            'port': self.port,
12143            'port_override': self.port_override,
12144            'secret_store_id': self.secret_store_id,
12145            'tags': self.tags,
12146            'username': self.username,
12147        }
12148
12149    @classmethod
12150    def from_dict(cls, d):
12151        return cls(
12152            bind_interface=d.get('bind_interface'),
12153            egress_filter=d.get('egress_filter'),
12154            healthy=d.get('healthy'),
12155            hostname=d.get('hostname'),
12156            id=d.get('id'),
12157            name=d.get('name'),
12158            password=d.get('password'),
12159            port=d.get('port'),
12160            port_override=d.get('port_override'),
12161            secret_store_id=d.get('secret_store_id'),
12162            tags=d.get('tags'),
12163            username=d.get('username'),
12164        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12068    def __init__(
12069        self,
12070        bind_interface=None,
12071        egress_filter=None,
12072        healthy=None,
12073        hostname=None,
12074        id=None,
12075        name=None,
12076        password=None,
12077        port=None,
12078        port_override=None,
12079        secret_store_id=None,
12080        tags=None,
12081        username=None,
12082    ):
12083        self.bind_interface = bind_interface if bind_interface is not None else ''
12084        '''
12085         Bind interface
12086        '''
12087        self.egress_filter = egress_filter if egress_filter is not None else ''
12088        '''
12089         A filter applied to the routing logic to pin datasource to nodes.
12090        '''
12091        self.healthy = healthy if healthy is not None else False
12092        '''
12093         True if the datasource is reachable and the credentials are valid.
12094        '''
12095        self.hostname = hostname if hostname is not None else ''
12096        self.id = id if id is not None else ''
12097        '''
12098         Unique identifier of the Resource.
12099        '''
12100        self.name = name if name is not None else ''
12101        '''
12102         Unique human-readable name of the Resource.
12103        '''
12104        self.password = password if password is not None else ''
12105        self.port = port if port is not None else 0
12106        self.port_override = port_override if port_override is not None else 0
12107        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12108        '''
12109         ID of the secret store containing credentials for this resource, if any.
12110        '''
12111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12112        '''
12113         Tags is a map of key, value pairs.
12114        '''
12115        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12133    def to_dict(self):
12134        return {
12135            'bind_interface': self.bind_interface,
12136            'egress_filter': self.egress_filter,
12137            'healthy': self.healthy,
12138            'hostname': self.hostname,
12139            'id': self.id,
12140            'name': self.name,
12141            'password': self.password,
12142            'port': self.port,
12143            'port_override': self.port_override,
12144            'secret_store_id': self.secret_store_id,
12145            'tags': self.tags,
12146            'username': self.username,
12147        }
@classmethod
def from_dict(cls, d)
12149    @classmethod
12150    def from_dict(cls, d):
12151        return cls(
12152            bind_interface=d.get('bind_interface'),
12153            egress_filter=d.get('egress_filter'),
12154            healthy=d.get('healthy'),
12155            hostname=d.get('hostname'),
12156            id=d.get('id'),
12157            name=d.get('name'),
12158            password=d.get('password'),
12159            port=d.get('port'),
12160            port_override=d.get('port_override'),
12161            secret_store_id=d.get('secret_store_id'),
12162            tags=d.get('tags'),
12163            username=d.get('username'),
12164        )
class UpdateResponseMetadata:
12167class UpdateResponseMetadata:
12168    '''
12169         UpdateResponseMetadata is reserved for future use.
12170    '''
12171    __slots__ = []
12172
12173    def __init__(self, ):
12174        pass
12175
12176    def __repr__(self):
12177        return '<sdm.UpdateResponseMetadata ' + \
12178            '>'
12179
12180    def to_dict(self):
12181        return {}
12182
12183    @classmethod
12184    def from_dict(cls, d):
12185        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
12173    def __init__(self, ):
12174        pass
def to_dict(self)
12180    def to_dict(self):
12181        return {}
@classmethod
def from_dict(cls, d)
12183    @classmethod
12184    def from_dict(cls, d):
12185        return cls()
class User:
12188class User:
12189    '''
12190         A User can connect to resources they are granted directly, or granted
12191     via roles.
12192    '''
12193    __slots__ = [
12194        'email',
12195        'first_name',
12196        'id',
12197        'last_name',
12198        'suspended',
12199        'tags',
12200    ]
12201
12202    def __init__(
12203        self,
12204        email=None,
12205        first_name=None,
12206        id=None,
12207        last_name=None,
12208        suspended=None,
12209        tags=None,
12210    ):
12211        self.email = email if email is not None else ''
12212        '''
12213         The User's email address. Must be unique.
12214        '''
12215        self.first_name = first_name if first_name is not None else ''
12216        '''
12217         The User's first name.
12218        '''
12219        self.id = id if id is not None else ''
12220        '''
12221         Unique identifier of the User.
12222        '''
12223        self.last_name = last_name if last_name is not None else ''
12224        '''
12225         The User's last name.
12226        '''
12227        self.suspended = suspended if suspended is not None else False
12228        '''
12229         The User's suspended state.
12230        '''
12231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12232        '''
12233         Tags is a map of key, value pairs.
12234        '''
12235
12236    def __repr__(self):
12237        return '<sdm.User ' + \
12238            'email: ' + repr(self.email) + ' ' +\
12239            'first_name: ' + repr(self.first_name) + ' ' +\
12240            'id: ' + repr(self.id) + ' ' +\
12241            'last_name: ' + repr(self.last_name) + ' ' +\
12242            'suspended: ' + repr(self.suspended) + ' ' +\
12243            'tags: ' + repr(self.tags) + ' ' +\
12244            '>'
12245
12246    def to_dict(self):
12247        return {
12248            'email': self.email,
12249            'first_name': self.first_name,
12250            'id': self.id,
12251            'last_name': self.last_name,
12252            'suspended': self.suspended,
12253            'tags': self.tags,
12254        }
12255
12256    @classmethod
12257    def from_dict(cls, d):
12258        return cls(
12259            email=d.get('email'),
12260            first_name=d.get('first_name'),
12261            id=d.get('id'),
12262            last_name=d.get('last_name'),
12263            suspended=d.get('suspended'),
12264            tags=d.get('tags'),
12265        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
12202    def __init__(
12203        self,
12204        email=None,
12205        first_name=None,
12206        id=None,
12207        last_name=None,
12208        suspended=None,
12209        tags=None,
12210    ):
12211        self.email = email if email is not None else ''
12212        '''
12213         The User's email address. Must be unique.
12214        '''
12215        self.first_name = first_name if first_name is not None else ''
12216        '''
12217         The User's first name.
12218        '''
12219        self.id = id if id is not None else ''
12220        '''
12221         Unique identifier of the User.
12222        '''
12223        self.last_name = last_name if last_name is not None else ''
12224        '''
12225         The User's last name.
12226        '''
12227        self.suspended = suspended if suspended is not None else False
12228        '''
12229         The User's suspended state.
12230        '''
12231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12232        '''
12233         Tags is a map of key, value pairs.
12234        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12246    def to_dict(self):
12247        return {
12248            'email': self.email,
12249            'first_name': self.first_name,
12250            'id': self.id,
12251            'last_name': self.last_name,
12252            'suspended': self.suspended,
12253            'tags': self.tags,
12254        }
@classmethod
def from_dict(cls, d)
12256    @classmethod
12257    def from_dict(cls, d):
12258        return cls(
12259            email=d.get('email'),
12260            first_name=d.get('first_name'),
12261            id=d.get('id'),
12262            last_name=d.get('last_name'),
12263            suspended=d.get('suspended'),
12264            tags=d.get('tags'),
12265        )
class VaultAppRoleStore:
12268class VaultAppRoleStore:
12269    __slots__ = [
12270        'id',
12271        'name',
12272        'namespace',
12273        'server_address',
12274        'tags',
12275    ]
12276
12277    def __init__(
12278        self,
12279        id=None,
12280        name=None,
12281        namespace=None,
12282        server_address=None,
12283        tags=None,
12284    ):
12285        self.id = id if id is not None else ''
12286        '''
12287         Unique identifier of the SecretStore.
12288        '''
12289        self.name = name if name is not None else ''
12290        '''
12291         Unique human-readable name of the SecretStore.
12292        '''
12293        self.namespace = namespace if namespace is not None else ''
12294        self.server_address = server_address if server_address is not None else ''
12295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12296        '''
12297         Tags is a map of key, value pairs.
12298        '''
12299
12300    def __repr__(self):
12301        return '<sdm.VaultAppRoleStore ' + \
12302            'id: ' + repr(self.id) + ' ' +\
12303            'name: ' + repr(self.name) + ' ' +\
12304            'namespace: ' + repr(self.namespace) + ' ' +\
12305            'server_address: ' + repr(self.server_address) + ' ' +\
12306            'tags: ' + repr(self.tags) + ' ' +\
12307            '>'
12308
12309    def to_dict(self):
12310        return {
12311            'id': self.id,
12312            'name': self.name,
12313            'namespace': self.namespace,
12314            'server_address': self.server_address,
12315            'tags': self.tags,
12316        }
12317
12318    @classmethod
12319    def from_dict(cls, d):
12320        return cls(
12321            id=d.get('id'),
12322            name=d.get('name'),
12323            namespace=d.get('namespace'),
12324            server_address=d.get('server_address'),
12325            tags=d.get('tags'),
12326        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12277    def __init__(
12278        self,
12279        id=None,
12280        name=None,
12281        namespace=None,
12282        server_address=None,
12283        tags=None,
12284    ):
12285        self.id = id if id is not None else ''
12286        '''
12287         Unique identifier of the SecretStore.
12288        '''
12289        self.name = name if name is not None else ''
12290        '''
12291         Unique human-readable name of the SecretStore.
12292        '''
12293        self.namespace = namespace if namespace is not None else ''
12294        self.server_address = server_address if server_address is not None else ''
12295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12296        '''
12297         Tags is a map of key, value pairs.
12298        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12309    def to_dict(self):
12310        return {
12311            'id': self.id,
12312            'name': self.name,
12313            'namespace': self.namespace,
12314            'server_address': self.server_address,
12315            'tags': self.tags,
12316        }
@classmethod
def from_dict(cls, d)
12318    @classmethod
12319    def from_dict(cls, d):
12320        return cls(
12321            id=d.get('id'),
12322            name=d.get('name'),
12323            namespace=d.get('namespace'),
12324            server_address=d.get('server_address'),
12325            tags=d.get('tags'),
12326        )
class VaultTLSStore:
12329class VaultTLSStore:
12330    __slots__ = [
12331        'ca_cert_path',
12332        'client_cert_path',
12333        'client_key_path',
12334        'id',
12335        'name',
12336        'namespace',
12337        'server_address',
12338        'tags',
12339    ]
12340
12341    def __init__(
12342        self,
12343        ca_cert_path=None,
12344        client_cert_path=None,
12345        client_key_path=None,
12346        id=None,
12347        name=None,
12348        namespace=None,
12349        server_address=None,
12350        tags=None,
12351    ):
12352        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12353        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12354        self.client_key_path = client_key_path if client_key_path is not None else ''
12355        self.id = id if id is not None else ''
12356        '''
12357         Unique identifier of the SecretStore.
12358        '''
12359        self.name = name if name is not None else ''
12360        '''
12361         Unique human-readable name of the SecretStore.
12362        '''
12363        self.namespace = namespace if namespace is not None else ''
12364        self.server_address = server_address if server_address is not None else ''
12365        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12366        '''
12367         Tags is a map of key, value pairs.
12368        '''
12369
12370    def __repr__(self):
12371        return '<sdm.VaultTLSStore ' + \
12372            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12373            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12374            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12375            'id: ' + repr(self.id) + ' ' +\
12376            'name: ' + repr(self.name) + ' ' +\
12377            'namespace: ' + repr(self.namespace) + ' ' +\
12378            'server_address: ' + repr(self.server_address) + ' ' +\
12379            'tags: ' + repr(self.tags) + ' ' +\
12380            '>'
12381
12382    def to_dict(self):
12383        return {
12384            'ca_cert_path': self.ca_cert_path,
12385            'client_cert_path': self.client_cert_path,
12386            'client_key_path': self.client_key_path,
12387            'id': self.id,
12388            'name': self.name,
12389            'namespace': self.namespace,
12390            'server_address': self.server_address,
12391            'tags': self.tags,
12392        }
12393
12394    @classmethod
12395    def from_dict(cls, d):
12396        return cls(
12397            ca_cert_path=d.get('ca_cert_path'),
12398            client_cert_path=d.get('client_cert_path'),
12399            client_key_path=d.get('client_key_path'),
12400            id=d.get('id'),
12401            name=d.get('name'),
12402            namespace=d.get('namespace'),
12403            server_address=d.get('server_address'),
12404            tags=d.get('tags'),
12405        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
12341    def __init__(
12342        self,
12343        ca_cert_path=None,
12344        client_cert_path=None,
12345        client_key_path=None,
12346        id=None,
12347        name=None,
12348        namespace=None,
12349        server_address=None,
12350        tags=None,
12351    ):
12352        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12353        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12354        self.client_key_path = client_key_path if client_key_path is not None else ''
12355        self.id = id if id is not None else ''
12356        '''
12357         Unique identifier of the SecretStore.
12358        '''
12359        self.name = name if name is not None else ''
12360        '''
12361         Unique human-readable name of the SecretStore.
12362        '''
12363        self.namespace = namespace if namespace is not None else ''
12364        self.server_address = server_address if server_address is not None else ''
12365        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12366        '''
12367         Tags is a map of key, value pairs.
12368        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12382    def to_dict(self):
12383        return {
12384            'ca_cert_path': self.ca_cert_path,
12385            'client_cert_path': self.client_cert_path,
12386            'client_key_path': self.client_key_path,
12387            'id': self.id,
12388            'name': self.name,
12389            'namespace': self.namespace,
12390            'server_address': self.server_address,
12391            'tags': self.tags,
12392        }
@classmethod
def from_dict(cls, d)
12394    @classmethod
12395    def from_dict(cls, d):
12396        return cls(
12397            ca_cert_path=d.get('ca_cert_path'),
12398            client_cert_path=d.get('client_cert_path'),
12399            client_key_path=d.get('client_key_path'),
12400            id=d.get('id'),
12401            name=d.get('name'),
12402            namespace=d.get('namespace'),
12403            server_address=d.get('server_address'),
12404            tags=d.get('tags'),
12405        )
class VaultTokenStore:
12408class VaultTokenStore:
12409    __slots__ = [
12410        'id',
12411        'name',
12412        'namespace',
12413        'server_address',
12414        'tags',
12415    ]
12416
12417    def __init__(
12418        self,
12419        id=None,
12420        name=None,
12421        namespace=None,
12422        server_address=None,
12423        tags=None,
12424    ):
12425        self.id = id if id is not None else ''
12426        '''
12427         Unique identifier of the SecretStore.
12428        '''
12429        self.name = name if name is not None else ''
12430        '''
12431         Unique human-readable name of the SecretStore.
12432        '''
12433        self.namespace = namespace if namespace is not None else ''
12434        self.server_address = server_address if server_address is not None else ''
12435        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12436        '''
12437         Tags is a map of key, value pairs.
12438        '''
12439
12440    def __repr__(self):
12441        return '<sdm.VaultTokenStore ' + \
12442            'id: ' + repr(self.id) + ' ' +\
12443            'name: ' + repr(self.name) + ' ' +\
12444            'namespace: ' + repr(self.namespace) + ' ' +\
12445            'server_address: ' + repr(self.server_address) + ' ' +\
12446            'tags: ' + repr(self.tags) + ' ' +\
12447            '>'
12448
12449    def to_dict(self):
12450        return {
12451            'id': self.id,
12452            'name': self.name,
12453            'namespace': self.namespace,
12454            'server_address': self.server_address,
12455            'tags': self.tags,
12456        }
12457
12458    @classmethod
12459    def from_dict(cls, d):
12460        return cls(
12461            id=d.get('id'),
12462            name=d.get('name'),
12463            namespace=d.get('namespace'),
12464            server_address=d.get('server_address'),
12465            tags=d.get('tags'),
12466        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12417    def __init__(
12418        self,
12419        id=None,
12420        name=None,
12421        namespace=None,
12422        server_address=None,
12423        tags=None,
12424    ):
12425        self.id = id if id is not None else ''
12426        '''
12427         Unique identifier of the SecretStore.
12428        '''
12429        self.name = name if name is not None else ''
12430        '''
12431         Unique human-readable name of the SecretStore.
12432        '''
12433        self.namespace = namespace if namespace is not None else ''
12434        self.server_address = server_address if server_address is not None else ''
12435        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12436        '''
12437         Tags is a map of key, value pairs.
12438        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12449    def to_dict(self):
12450        return {
12451            'id': self.id,
12452            'name': self.name,
12453            'namespace': self.namespace,
12454            'server_address': self.server_address,
12455            'tags': self.tags,
12456        }
@classmethod
def from_dict(cls, d)
12458    @classmethod
12459    def from_dict(cls, d):
12460        return cls(
12461            id=d.get('id'),
12462            name=d.get('name'),
12463            namespace=d.get('namespace'),
12464            server_address=d.get('server_address'),
12465            tags=d.get('tags'),
12466        )